Blog: Posts from May, 2008

Posts from May, 2008
Thursday, May 29, 2008PrintSubscribe
Data Aquarium Framework

Nothing is simpler today than publishing a database on the web. A third generation of ASP.NET provides countless tools and components that assist you with this task. Yet, every time you work on your next database web application a thought comes to mind - why is it so difficult to make your data look good on the web?

Sure, you can throw in a data source and a few data presentation controls to have a quick and dirty web form in just a few minutes. Next you have to change the page layout, handle user validation errors, apply better styling, customize columns and fields, create additional pages to have a data lookup grid. By the end of the day you have a sizable chunk of code, which grows up from virtually nothing. Then you are bracing yourself to hear user requests to add a few data filters and have the screen look different to each user role.

Does it have to be that way?

Naturally you are looking for advanced commercial controls and components to ease the pain. You are rarely getting a real relief. Instead you are obtaining a pretty face for you forms at the expense of a bloated code.

Sometimes there is nothing you can do about it. Your web form simply requires a very high level of customization and you have to deal with it. But this is not the case for most of your web projects.

A better approach is needed. Let's consider a better way to create database web forms. Let's make them look like the one in the picture.

See the live Demo now

First, you start with SQL query. A simple SELECT statement that joins together a database table with the linked lookups will provide a method of obtaining a real world object entity, which is supposed to be displayed in a web form.

select "Products"."ProductID" "ProductID" ,"Products"."ProductName" "ProductName" ,"Products"."SupplierID" "SupplierID" ,"Supplier"."CompanyName" "SupplierCompanyName" ,"Products"."CategoryID" "CategoryID" ,"Category"."CategoryName" "CategoryCategoryName" ,"Products"."QuantityPerUnit" "QuantityPerUnit" ,"Products"."UnitPrice" "UnitPrice" ,"Products"."UnitsInStock" "UnitsInStock" ,"Products"."UnitsOnOrder" "UnitsOnOrder" ,"Products"."ReorderLevel" "ReorderLevel" ,"Products"."Discontinued" "Discontinued" from "dbo"."Products" "Products" left join "dbo"."Suppliers" "Supplier" on "Products"."SupplierID" = "Supplier"."SupplierID" left join "dbo"."Categories" "Category" on "Products"."CategoryID" = "Category"."CategoryID"

You may have a few queries with the same columns, but have them return a different subset of records by adding the WHERE clause, and various sorting options via the ORDER BY clause. This will give alternative views to your entity, which in this case is Products from the Northwind sample database that comes with Microsoft SQL Server.

A wealth of information is available in this query. You know the base table name ("dbo"."Products"), the list of columns, the where and order by sections if any. This informati0n allows to automatically construct UPDATE, INSERT, and DELETE statements when the time comes to update the database. You may also select distinct column values, apply additional filters to the where clause, or alter the query to change the sort order of rows.

The class Regex from System.Text.RegularExpressions namespace will help with that.

Second, create an inventory of all fields returned by SELECT query. It may look like the one displayed below. Such inventory can be stored in XML file along with query itself.

NameTypeAllow NullsPrimary KeyLabelRead OnlyDefaultLookup
ProductNameStringNoNoProduct NameNo
SupplierIDInt32YesNoSupplier# No
SupplierCompanyNameStringYesNoSupplier Company NameYes Supplier
CategoryCategoryNameStringYesNoCategory NameYes Category
QuantityPerUnitStringYesNoQuantity Per UnitNo
UnitPriceDecimalYesNoUnit PriceNo((0))
UnitsInStockInt16YesNoUnits In StockNo((0))
UnitsOnOrderInt16YesNoUnits On OrderNo((0))
ReorderLevelInt16YesNoReorder LevelNo((0))

This inventory is invaluable in generating SQL statements to read and write the database information. It is also suitable to use as a design document when you start creating a database web form. If the field inventory is stored in XML format then you can use XPath expressions to easily lookup required information just in time when you need it.

Third, define presentation views on top of the field inventory. Not all of the fields are displayed in all views of a typical web form. You can greatly simplify control of the GUI presentation by listing views with data fields that are actually displayed to the user.

In our example, you may define one grid view to present a list of record, a form view to display a single record in the edit mode, and another form view that will allow user to add new records. You can see the grid view in action in the picture above.

ViewTypeField NameAlias Field NameColumnsData Format String
grid1GridProductName 40
QuantityPerUnit 20
UnitPrice 15c
UnitsInStock 15
UnitsOnOrder 15
ReorderLevel 15
editForm1FormProductName 40
QuantityPerUnit 20
UnitPrice 15c
UnitsInStock 15
UnitsOnOrder 15
ReorderLevel 15
createForm1FormProductName 40
QuantityPerUnit 20
UnitPrice 15c
UnitsInStock 15
UnitsOnOrder 15
ReorderLevel 15

Use Microsoft Ajax Extensions to create an AJAX component to render this data as HTML. Spruce it up with some Ajax Control Toolkit goodies to enhance the presentation. You will also need to deliver the views and fields information to this component via a call to a JSON-enabled web service, which can be done with the tools that Visual Studio 2008 provides out of the box. Here is the editForm1 in action.

editForm1 in action

Fourth, define a state machine for your form. The most time consuming process in web form development is figuring out the logic of the screen mode changes. Considerable amount of code may need to be written to cope with the data validation errors, unpredictable user actions, such as clicking on the browser's Back button, and other such events.

AJAX components are generally tolerant to the evil Back button. But AJAX techniques along are not solving the problem.

Consider implementing a state machine that allows a flow of screen mode changes in the context of the previously executed command. Make sure to break down the flow by the context. For example, in our example we have commands specific to a grid view row, commands displayed in the action bar, and a row of push buttons displayed in forms.

ScopeLast CommandCommandArgumentHeader Text
Grid SelecteditForm1
EditUpdate Save
Form Edit
Cancel Close
EditUpdate OK
NewInsert OK
Action Bar NewcreateForm1
CustomExportCsvExport to Spreadsheet
CustomExportRsvView RSS Feed
CustomMyCommandMy Command

Implement this state machine within the AJAX component that is responsible for user interface and you are done.

Data Aquarium Framework implements the steps described above and can be used as a foundation of your own project. A few source code files that provide server-side plumbing and a simple Data Controller web service that serves as gateway for the Data View client-side AJAX component allow for a simple Model-View-Controller implementation, which works great in many scenarios.

You can download the sample of the XML data controller descriptor. The data controller descriptor design can be illustrated by the following picture.


Data Aquarium Framework is a premium project that comes with Code OnTime Generator. The entire framework source code is included in the generated source code. Feel free to make any adjustments and get your database web forms done faster.

Download Code OnTime Generator here.

You can see the application built with Data Aquarium Framework in action right in this page if you scroll to the bottom.

Sunday, May 25, 2008PrintSubscribe
Getting Started

Code generation is a well-established technique of software development. Modern development tools are using code generation whenever there is a need to create a chunk of source code of a well-known structure. For example, plumbing code to interact with a web service or a business object layer library for a database are both good candidates to be outsourced to a code generator.

How difficult is it to create a code generator?

Consider Microsoft.NET Framework. A dedicated namespace System.CodeDom is provided to allow easy programmatic creation of source code trees with additional classes capable to convert a code tree into actual source code in the .NET language of your choice. You can even compile the code directly from the tree and have it executed! So the answer to the question is that it is not that difficult if you are relying on a toolset such as Microsoft.NET.

Why would you want to build a code generator?

The reality of software development is that it is not enough anymore to have a great hierarchy of classes that can be reused by many projects. To be productive you need an initial set of source code files that are linked to a great class library and shaped to solve a specific business problem. This is especially true if you are interacting with the databases, invoking external web services, or building user interface screens. Most of these tasks can be done with automatic code generation tools.

Take a look at the great example below. The ASP.NET 3.5 web application with Ajax Control Toolkit and JSON web service is running right in the middle of the page and was created with .

This shows that very sophisticated applications can be instantly created given the right set of tools. The development process is considerably shorter - in seconds you are ready to start tackling the real business problems instead of figuring how to write client AJAX calls to your JSON web service.

How do you build a great code generator?

A code generation project requires some sort of database to store project requirements specified by the user. The most lightweight, flexible and universally supported medium is XML. Another popular choice is to store project settings in the database. Database does make it more difficult to alter project structure and creates sometimes additional level of complexity, which might not be needed.

XML naturally suggests three other technologies - XSD, XPath, and XSLT.

Use XSD schemas to ensure that users are not making mistakes when populating project files. Tools, such as , will automatically recognize the schemas and assist with intelli-sense when users are working with the XML source.

XPath is great if you need to create a project builder for your code generator. You can easily inspect the content of the project XML files and allow the code generator to make decisions about the steps that need to be executed.

Transform and shape the project data with XSLT stylesheets. For example, you can come up with an intermediate form of source code that will be naturally produced by applying XSLT transformations to the project XML files and have them later converted into the source code. Don't reinvent the wheel, go with System.CodeDom or any other comparable technology available in other programming platforms, to do such conversion.

A great code generator will provide capability to write user interface forms to help user in configuring the projects. The best bet is to use HTML and AJAX techniques to create a project browser. The scripts running in the pages can interact with the XML files and provide user input to the code generator.

Download Code OnTime Generator now