This is a showcase review for our sponsors at The Code Project. These reviews are intended to provide you with information on products and services that we consider useful and of value to developers.
Iron Speed Designer Version 5.0 now Released
PDF report generation and Excel exporting features enhance database applications.
Download Free Trial
"Database Layer—all your SQL and transaction management:
All the SQL queries for data display and reporting as well as record insertion, modification and deletion. Advanced features include multi-table joins and a page-based transaction model."
Table of Contents
Developing web applications provides an opportunity to build highly-creative, user-friendly applications like these:
To most application users, web applications look better than traditional desktop applications, and they're also perceived as much easier to use. Web applications afford the opportunity to reach out to both internal and external users like never before, and many organizations are enhancing web applications to integrate customers and suppliers, in addition to internal users.
At the same time, building web applications put you, the developer, in a completely different scenario. Web-based applications add additional development burdens of security, stateless transaction management, page-based navigation, as well as a variety of user interface features, that you wouldn't normally worry about in traditional desktop client-server applications. Even though platforms like the Microsoft .NET Framework deliver the basic OS-level services for these applications, you still must
write SQL statements, create hundreds of web pages, and code the business logic.
Smart IT departments are efficiently conquering many of these critical issues, and focusing resources on creating intellectual property that's truly unique to their businesses. They are using a new breed of software tools called application generators to eliminate hand-coding of the infrastructure programming.
Application generation takes a giant leap forward, offering a broader, more comprehensive solution. Application generators such as Iron Speed Designer create a significant portion of your entire application for you, frequently as much as 80%-90% of the application.
Accelerating the development cycle without sacrificing performance, features and interoperability, are key benefits provided by application generation.
This white paper describes how one application generator, Iron Speed Designer, works. It uses an Iterative Drag and Drop development style most professional application developers find comfortable.
Imagine creating 80% to 90% of your application just by dragging components onto web pages in a visual editor. All of the components – tables, panels, and controls – are magically hooked up with each other and the underlying databases, and all the associated code is generated for you. That's exactly what Iron Speed Designer does, illustrating the power of drag and drop application generation.
Iron Speed Designer's approach to application generation is very straightforward:
- Start with your application-specific data model – an existing database or other data asset.
- Automatically create a set of fully functional application web pages for common database operations, such as adding, editing and viewing data.
- Quickly and easily construct web pages by dragging and dropping components – a comfortable development style for most developers.
- Generete everything needed for a functional n-tier application – all the web pages, code and SQL – and deliver a working, bug-free application.
- Automatically generate "pure" source code in native .NET languages, such as C# and Visual Basic, which do not require proprietary run-time servers or libraries.
- Generate complete and well organized source code that's easy to modify and extend.
- Allow handmade code customizations to the generated application, automatically preserving them during subsequent application regenerations.
Let's see exactly what we mean by drag and drop application generation.
"Drag and drop" application generation recognizes that only a small percentage of the code in any application is the "secret sauce" – the truly unique elements of business logic that differentiate one application from another. The vast majority of most web applications consists of fairly standard components – tables, panels, and controls – that lend themselves to being automatically generated and connected by an application generator. Only the unique application logic remains to be written by hand.
A brief example illustrates this point. Suppose you need to build an order entry system that allows sales people to create, edit and retrieve sales orders. This application might have an input form for adding and editing orders and a table page for displaying orders for any given customer. Using drag and drop application generation, the developer drags tables (data grids), fields and other components onto web pages and then selects the appropriate mapping between the underlying database and web page components. When ready, the developer lets the application generator produce the underlying application source code and SQL, including code for all of the web pages, controls, and database connectivity infrastructure.
Applications like these lend themselves well to application generation because they use typical database connectivity and application infrastructure. Data is either being entered into a web form and inserted into the database or data is beinig retrieved from the database and displayed on a web page. These data operations are ideal for a templatized approach to application development, enabling an application generator to create the application and its infrastructure based on code templates – standardized and well-accepted ways to perform certain common operations.
Why is this drag and drop method so important and useful for modern .NET application development?
- This is how developers work. Most application development projects start with a handful of HTML page mock-ups – or white board sketches – and a database schema. Iron Speed Designer uses your web page designs and database schema as inputs and generates a large volume of custom infrastructure code, including all the transaction processing code and SQL, in a fraction of the time of hand-coding.
- Application users are familiar with the web and with sophisticated forms and navigation features. Most developers dread building features such as paginated reports, hierarchical navigation, filtering, and full text search, because the amount of time required is not proportional to the challenge or interest they create. They look simple to implement and application users expect them, but there's usually quite a lot of coding involved. Iron Speed Designer automatically includes these sorts of features, freeing you to focus on more interesting application logic work.
- Connecting individual pages to the database is mind-numbing work. Each page in a web application can contain five or ten separate SQL queries, each of which has to be written, debugged, and vetted for performance. However, by using application generation tools, you don't have to worry about manually programming web pages, controls, or SQL. The repetitive nature of data insertion, retrieval and display operations permit their use as repeatable templates, or code patterns, in an application generator.
Most web-based applications are based on a three-tier architecture comprised of:
- A Presentation Layer—the web-based user interface including database-connected forms, tables, and reports.
- An Application Layer— C#, Visual Basic .NET, or Java application functionality.
- A Database Layer—SQL and transaction management code.
Implementing transaction-based web applications can be difficult because of the stateless nature of the web. Because web applications are stateless, they can require complex database management to implement complicated transactions, especially those spanning multiple web pages. While a client-side browser can display pages, it can't be used to implement database transaction logic. As a result, the server-side application must coordinate and manage every aspect of these database transactions.
The next chapter shows how Iron Speed Designer builds each of these layers.
Translating an end-users' vision into a functional and intelligent web application requires three main steps, each of them non-trivial.
- Design and create the hundreds of web pages required to access and run your application, including input forms, reports, and data displays;
- Build the application's basic functionality, augmented with sophisticated features ranging from filtering and sorting, to search and pagination;
- Connect the pages and their components to the database, implementing the underlying SQL and transaction management code.
Fortunately, Iron Speed Designer can help with each of these steps. In fact, the process begins with your vision, turning your HTML pages into sophisticated, custom ASPX pages with the underlying code and SQL.
Iron Speed Designer is an application generator for building full-featured Microsoft .NET web applications in just a couple of hours, shaving months off the development cycle. Iron Speed Designer is different from other rapid development tools because it works just as most developers do, from the application's user interface inward to the underlying data model. Plus, the tool generates complex user interface pages, and all the SQL and supporting code, without you having to design or code the pages, or know SQL.
Using Iron Speed Designer, a custom, working application—not just a prototype or individual components—is generated in just a few hours. Modifications and enhancements to the user interface and application layer are preserved each time your application is regenerated.
Typically, only a handful of high-level pages are actually mocked up by a web designer, and the developer must create the rest of the pages by hand based on these designs. Or, maybe the developer is left to his own imagination when it comes to application design. While designing the application's look-and-feel is not trivial to begin with, repeating it over and over for each of the hundreds of pages required to run your web application is a significant chore.
Iron Speed Designer saves you this struggle by automatically creating a suite of pages for each database table or database view in your application. These pages reflect the basic operations performed with any database table: Create record, Retrieve record, Update record and Delete record –sometimes referred to as C/R/U/D pages.
Iron speed Designer goes beyond these basics, though, by creating these pages, using only the schema information provided by your database:
- Show Table – a paginated, interactive report view of a table or query's data.
- Edit Table – an editable data grid useful for editing a quantity of records.
- Add Record – a page for inputting data for an individual table or multiple tables.
- Edit Record – a page for editing data in an individual record or query
- Show Record – a page for viewing data from one or more tables and queries.
- Master-detail pages – pages for displaying, adding, and editing information from subsidiary "detail" tables referencing a "master" parent table, typically through foreign key relationships.
The generated pages include corresponding application layer code, database transaction management code, and the underlying SQL queries and stored procedures. All of the generated pages are automatically linked together with a menu navigation structure, providing an out-of-the-box application with no additional coding required.
How physically attractive are these automatically created web pages? Iron Speed Designer uses a template-driven approach to generate web pages. Over 25 different design themes are included with the product, providing a variety of layouts, color schemes, and other important visual attributes. In short, generated applications look great without any customization. More importantly, these design themes can be customized, allowing developers to either modify one of the design themes to their liking or create one of their own.
Design themes are comprised of an extensible set of HTML panels – snippets of HTML that can be as simple as one tag or as complex as an entire page. Panels contain the code generation tags that instruct Iron Speed Designer to generate data-bound controls at specific locations in the web pages. (More on this shortly.) Panels can also contain VB Script, Java, DHTML, or any other presentation layer code that is desired in the final application. Panels can utilize a common style sheet, ensuring look and feel consistency between panels, or the panels may be completely unrelated.
Because developers can add their own panels to a design theme, the application generator is extensible, allowing developers to replicate visual elements of their own design from application to application.
Iron Speed Designer uses a set of intermediate web pages called layout pages to define your application's web-based user interface and underlying functionality. Iron Speed Designer translates these layout pages into a working n-tier application with well-partitioned service layers.
Layout pages are just HTML pages containing simple XML-based code generation tags that instruct Iron Speed Designer which components to generate in the final application – everything from a data grid table to filters to data-driven menus. Code generation instructions correspond to HTML and source code templates that are automatically included and customized to the specific application when Iron Speed Designer generates application.
You insert code generation tags at each place in your HTML layout pages where you want a page control to appear using several methods:
- The Application Wizard that automatically generates template-based pages for you.
- Iron Speed Designer's visual page editor and component toolbox palette for dragging and dropping panels and components onto a page.
- By hand, using either Iron Speed Designer's built-in HTML editor or your favorite external HTML editor.
Once your code generation tags are placed in your layout pages, a set of wizards and properties dialogs gather the information required to connect the resulting controls to the underlying databases and to set other application parameters. You specify which database tables, fields, and views to use for each component. Thus, most of the traditional coding process is reduced to a straightforward configuration exercise.
In this way, Iron Speed Designer helps you quickly construct a complete, custom web-based user interface for complex web applications – typically hundreds or even thousands of distinct web pages, including:
- Database table view pages with complex data grid controls
- Data input forms and editable tables
- Master-detail pages
- Add/Edit/Show Record pages
- Account management pages.
When generating the application, Iron Speed Designer reads the code generation tags in the layout pages and generates corresponding .NET data-bound controls, server-side code-behind logic and transaction management code – ASPX, C# or Visual Basic and SQL – that is the bulk of the application. Thus, you do not have to write any code to create sophisticated user interface-based applications with Iron Speed Designer. (Code generation tags have no run-time effect on your application because they are not present in the generated application.)
Most IT departments have an SQL "ombudsman" who is an expert SQL DBA and checks the SQL code written by all the other developers. Iron Speed Designer simplifies the developer's and the ombudsman's tasks by automatically generating every SQL query, and the wrapper code around it, for each web-based component that accesses the database.
The code generated for the presentation, application, and database layers is itself template-based, just like the previously described HTML panels. Thus, application developers can change the code that is regularly generated for each application to include specialized features that might be commonly used within an organization.
It's virtually impossible to generate applications that require no code customizations – extensions made by hand to the generated application to add custom application logic, integrate with third-party components, and interface with external systems. While many administrative and data management applications can escape the need to write any code by hand, most production applications have some amount of hand-coding.
The application generation process must generate code that is readable, easy-to-understand and easy-to-modify; otherwise the time benefits achieved by application generation are for naught. Perhaps the principal concern in using an application generator is understanding how you extend and customize the generated application so that your enhancements are preserved each time the application is regenerated.
One of the biggest challenges of application generation is that of orphaned code. Orphaned code is code that, once generated, cannot be modified or extended without severing the application generator's ability to regenerate that code without losing one's code customizations. In today's high-pressure IT department, there is no place for code that can't be leveraged for both current projects and future applications.
Iron Speed Designer allows your application to be regenerated repeatedly without requiring you to re-integrate your external code extensions. This is accomplished using a class hierarchy in the generated application, which has set of safe class files expressly for code integration that are not affected by application regeneration. While there are several layers of safe classes at various points in the generated application, safe classes are typically at the top of the inheritance hierarchy, so they inherit from all of the generated code underneath them. This means your code customizations have access to the full functionality of the generated application, all the way down to the .NET framework.
Iron Speed Designer generates the underlying safe classes for your application only once, typically the very first time each page is generated. Once the individual safe class for a page has been created, it is never overwritten, thus making it safe to add your own code to and modify these safe classes. Only the generated class files – the automatically generated portions of your application – are ever regenerated; the safe class files are never regenerated, preserving your code customizations.
Using your favorite programming language including C#, Visual Basic, or J#, you can extend your generated application to:
- Integrate with external systems
- Add custom application logic
- Add additional validation code.
In most applications written for the Microsoft .NET Framework, the functionality and logic in the Application Layer are derived from a set of C# or Visual Basic .NET (or other .NET common language runtime language) classes for page management, database access, and data validation. These classes provide advanced user interface controls and server management.
The class hierarchies generated by Iron Speed Designer derive from the base classes in the .NET Framework. Sub-classing allows you to intercept Windows messages going to a form or control, among other benefits. As long as your modifications are physically segregated in safe class files, your application can be regenerated repeatedly without re-integrating your code extensions.
Using Iron Speed Designer, simply subclass the appropriate page, control or database object in the appropriate safe class file and add your code extension. You can override any of the functions or methods in the generated base classes, or write your own methods in combination with the existing base class methods. Then, regenerate the application to reflect your changes. Your code extensions are not overwritten when the application is regenerated, allowing you a high degree of flexibility in making code extensions to the application.
Iron Speed Designer generates native .NET code, including ASPX pages, ASCX controls, SQL statements, C# and Visual Basic code. Developers enjoy unrestricted access to 100% of the generated code and any modifications to the application are automatically preserved when the application is regenerated. There are no run-time license fees or special server software requirements for applications built with Iron Speed Designer.
Even for experienced developers, scalability is hard to implement. Since all of the business logic in web applications is concentrated server-side in the application layer, scalability becomes a big issue for web applications. Functionality isn't distributed to the client-side as it is with client-server applications, so you can't rely on the application user's machine to off load computationally intensive tasks. Hence, improperly designed applications can cause performance bottlenecks in the middle-tier. Iron Speed Designer builds applications with a three-tier architecture that scales easily, including optimized SQL, and advanced transaction, cache, and session management techniques.
There are likely dozens of different pages in your application that each need SQL queries to implement functionality, plus wrapper code to glue it all together. Those pages include input forms, reports, and all sorts of pages where data is displayed in a variety of formats. Writing the SQL queries is often the most challenging task for web application developers, usually requiring the help of a DBA or SQL specialist.
It's important to consider these application generation issues:
- SQL Efficiency
- Location of the SQL statements
- Transaction management
- Concurrency handling
- Cursor management
SQL statements are hard to write even if you are an expert. However, writing efficient SQL queries can have a genuine effect on the performance and scalability of your application. This is especially true in the state-less environment of the web, where maintaining transaction state between pages is difficult.
Iron Speed Designer approachs SQL generation from an efficiency perspective. For example, it places queries for multi-table joins in a single query to reduce round trips to the database. For optimal performance, it takes into account fields that are indexed. It even gives you the choice of placing your SQL directly in the application layer or in stored procedures.
Technology that generates SQL statements must be tied specifically to your database schema. Generic queries (queries composed on-the-fly that do not use parameterized field values) can slow down application performance since they often require several round trips to the database to complete. Specific queries that include the names of field values save trips because they use the actual field names from your database. This is how you would write the statements by hand.
Most DBA's prefer keeping SQL in stored procedures because it keeps all the queries in one place where they can be conveniently accessed and reviewed. Moreover, storing SQL in stored procedures can improve efficiency by pre-parsing the queries and reducing round trips to the database. Iron Speed Designer, for example, gives you the option of placing generated SQL statements in stored procedures instead of in line, in the application code itself.
Most developers use stored procedures to enhance run-time performance and minimize the number of round trips between the application program and the database. Getting information into and out of stored procedures must be done through a technology that interfaces with the database, such as ADO.NET.
There are, of course, good reasons to place SQL queries directly in the database as well (e.g.: legacy applications and DBA preference). Because Iron Speed Designer generates all the SQL statements, developers don't have to learn proprietary stored procedure languages, such as PL/SQL (Oracle's stored procedure language) or Transact-SQL (Microsofts SQL Server's language).
In web-based applications, it's particularly difficult to maintain state from one page to another because of the stateless nature of the web. This makes it important to understand what constitutes a transaction and when it should be committed to the database. For example, it is often difficult to construct transactions that gather data across multiple pages, such as a shopping cart, because there are few options for storing information collected on those pages other than in the database, in the .NET cache, or in browser cookies.
Iron Speed Designer frees you from the burden of implementing these schemes.
In any multi-user environment, concurrency becomes an issue when two users update the same record in the database, one after the other. The way your application handles concurrency affects the ability of your application to handle simultaneous transactions against the same records.
In some applications, the second user to update a record will overwrite the changes made by the first. In others, the application will warn the second user that the record they are viewing has just been updated. In still others, the second user's view is automatically updated when the first user updates the record.
In traditional application development, the developer has to hand-code concurrency handling into the application layer. This can be tricky code to write, and it has to be written for each transaction in your application. Unfortunately doing it right doesn't earn you any special recognition whereas mistakes can have you hunting bugs for days. Iron Speed Designer creates this concurrency management code for you, saving hours of hand-coding headaches. It generates optimistic concurrency handling code for each of your transactions so users cannot unintentionally overwrite each other's changes.
A database cursor is the resulting set of records returned by an SQL query. The cursor allows you to request each record in sequence so that the query results may be displayed in a data grid, report or otherwise operated upon. For example, as an application user moves from page to page in an on-screen report, the subsequent page's data is retrieved from the cursor and displayed. It's also commonplace for applications to iterate over the result set, performing some calculation or other update to each of the records in the result set.
Data recency. One issue that emerges with cursors is the freshness of the data in the result set. As long as the cursor is in use, it contains the set of records retrieved when the query was originally performed. However, this data may grow stale over time, especially if the query result is being displayed in a screen that an application user is reviewing over a period of time – minutes or hours. In applications where the underlying data changes frequently, it may be desirable to rerun the SQL query as the application user moves from page to page in their report. This ensures that each displayed page has the most current data. While this also places an extra load on the database because it must rerun the query more frequently, all modern relational databases have very good data cache management that significantly reduces the cost of frequently rerunning queries.
Data management. A second issue to consider is whether the entire result set is pulled from the database into the application layer, a well-known problem with .NET data grids. When a result set contains only a few hundred records, moving all of the data into the application program requires minimal bandwidth and memory to store and manipulate the result set in the application. However, when the result set has hundreds of thousands or millions of records, it becomes nearly impossible to efficiently move all of that data into the application program. Very few application programs are structured to manipulate that quantity of data in memory without additional file management logic, which defeats the purpose of using the underlying database which provides exactly these facilities. So, in applications where the result sets can be large, it's best to retrieve only a manageable subset of the result set from a cursor – such as one page of data – operate on that data, and then request the next subset.
Applications generated by Iron Speed Designer use database cursors to retrieve data from the database. The cursor is used to retrieve the number of records being displayed on the database table view web pages. Only one page of data is retrieved from the database and displayed at a time, minimizing the data transmission load and the application's memory storage requirements. Query results are not stored in a temporary database table view. They are retrieved directly from the database and displayed to the user.
Although most corporations take security precautions at the network level, the majority of application security must be built into the application code itself. Further, as much as we all wish it, the hackers and thieves will not disappear, especially when our networks connect to the public Internet and interface with outside customer and supplier systems. The bottom line is that a large part of your application security is in the program code itself. You can increase your application's security by taking advantage of the powerful benefits of application generation.
Applications generated with Iron Speed Designer utilize the highest level of security features offered in the .NET Framework and include built in security. Additionally, you can easily add features such as Windows authentication and active directory single sign-on. And, applications generated by Iron Speed Designer work well with existing network firewalls.
Iron Speed Designer generates applications with built-in features, such as:
- Role-based access control
- Automatic sign-out
- Data transmission encryption
- Password storage in your own database.
Building web applications is complicated and time-consuming. The ROI from using Iron Speed Designer versus hand coding means more efficient utilization of key personnel, reduced development and testing time, and more rapid deployment of robust applications.
Let us show you how Iron Speed Designer can accelerate your web application development efforts overall, and jump-start your Microsoft .NET application development.
Presentation Layer—a complete web-based user interface:
Sophisticated web-based user interface pages, including database-connected forms, tables and reports. Advanced features include reports with filtering and sorting, full-text search, navigation, data validation, and table pagination.
Application Layer—native .NET program code:
Easily extensible class hierarchy built on the .NET Framework base classes, as well as enterprise-class features such as role-based user access control.
Database Layer—all your SQL and transaction management:
All the SQL queries for data display and reporting as well as record insertion, modification and deletion. Advanced features include multi-table joins and a page-based transaction model.
Download the Free Trial now!