Beyond DataBinder in ASP.NET Using VB.NET


The DataBinder.Eval method is a very handy way to achieve data binding in Web Forms applications. Because it uses reflection, it is totally generic in the types of data source that it can handle. Of course this versatility comes at a price. The performance implications of reflection are often remarked upon. However even more important to my mind is the inability to handle situations where the data item doesn't exist or to gain access to ancillary information such as validation error messages.

If we are willing to restrict ourselves to the use of DataSets as our data source, we can enhance the functionality considerably allowing us to produce rich UIs for handling validation errors such as the example below.

In this article, I'm assuming you have at least played with the Web Forms designer in Visual Studio and are familiar with Web Forms binding expressions.

Non existence of Data

It is not uncommon in a UI to have a situation where the data being bound-to does not exist. One example would be the picking of a customer for an invoice where the system might automatically fill in various controls with the address of that customer. Before the customer has been picked, there would be no data for these controls to be bound to. Unfortunately the standard DataBinder.Eval function will generate an exception in such a situation.
There is a slightly more contrived example in the screen grab below where we are entering a set of Staff Information records. Initially there are no records so we would expect all the data entry controls to be either read-only or disabled.

Take for example the "Date Of Birth" TextBox. It has a Binding that ensures ReadOnly is set whenever no row exists for the data that it intends to display. This is done with a call to DataSetBinder.RowExists.

<asp:textbox id=TextBox2 style="Z-INDEX: 106; LEFT: 144px; POSITION: absolute; TOP: 160px"
Text='<%# DataSetBinder.Eval(WebForm1_Staff1,"Staff.DateOfBirth","{0:d}") %>'
ReadOnly='<%# Not DataSetBinder.RowExists(WebForm1_Staff1,"Staff") %>'
ToolTip='<%# DataSetBinder.GetError(WebForm1_Staff1,"Staff.DateOfBirth") %>'
CssClass='<%# IIf(DataSetBinder.HasError(WebForm1_Staff1,"Staff.DateOfBirth"),"error","")%>'>

The binding of the Text property using the DataSetBinder.Eval method is very similar to what would be done with DataBinder with even the paramaters being the same. However DataSetBinder.Eval return the DefaultValue for any data that doesn't exist instead of throwing an exception. It obtains this from the DataSet which in turn derives it from the dataset schema. (The Binding of ToolTip and CssClass is used for validation which is discussed below.)

The first parameter to Eval is the data source from which to start, normally the DataSet, although it could be "Container" if the control is inside a template. The second parameter uses a syntax similar to the way data is addressed in a Windows Forms Binding. This parameter normally starts with a table name followed by a series of child relationship names if any and followed finally by the column name. However in the case where the control is inside a template, it starts as you might expect with "DataItem".

Binding Expression for a Top Level Control:
Eval(DataSet,"{TableName} [.{RelationName}] .{ColumnName}")

Binding Expression for a Control inside a template:
Eval(Container,"DataItem [.{RelationName}] .{ColumnName}")

The parameters for RowExists are exactly the same as Eval above. However the final .{ColumnName} is omitted from the second parameter, because the whole row is being specified rather than a column within it.

As well as making data entry control read-only or disabled, buttons should be disabled in cases where they require a row of data to exist. For example the Add button for a master Staff Information record should obviously be enabled always, whereas the Add button for a Training course detail should not be enabled unless there is a master record to attach it to. As you might expect this is handled by binding the Enabled property using another call to DataSetBinder.RowExists.

<asp:button id=Button10 style="Z-INDEX: 111; LEFT: 680px; POSITION: absolute; TOP: 272px"
Enabled='<%# DataSetBinder.RowExists(WebForm1_Staff1,"Staff")%>'
CommandName="Add" Text="Add">

When the user presses the Add button to add the first Staff Information record, you can see how the various controls update their Enabled or ReadOnly states in the screen grab below.


In real world applications, validation can often be quite complex. It may involve checking elaborate relationships between the data entered or looking up additional data not available on the client. For this reason, while it's worth doing some simple sanity checking on the client, I'm a big fan of doing the bulk of the validation when the attempt is made to save the users data to the data tier. ADO.NET has a mechanism for recording errors against specific columns in specific rows, so this is the obvious way to return validation to the client.

Below is a sample piece of validation for an instance of Staff Information. It does some of the usual things like checking for required data. However it also checks for overlaps in the dates of courses- an example of the more complex validation that is often neccessary.

' Return True if the two Date Ranges overlap

Private Function RangesOverlap(ByVal s1 As Date, ByVal e1 As Date, ByVal s2 As Date, ByVal e2 As Date)
If Date.Compare(s1, e2) <= 0 And Date.Compare(e1, s2) >= 0 Then
' This function is an example of the sort of constraints that might be applied
' to data prior to it being commited to the database
Private Function ValidateData() As System.Boolean
Dim dtStaff As DataTable = Me.WebForm1_Staff1.Tables("Staff")
Dim dvStaff As DataView = dtStaff.DefaultView()
For Each drv As DataRowView In dvStaff
If TypeOf drv("Name") Is DBNull Then
drv.Row.SetColumnError("Name", "Name is Required")
End If
TypeOf drv("DateOfBirth") Is DBNull Then
drv.Row.SetColumnError("DateOfBirth", "Date Of Birth is Required")
ElseIf (System.DateTime.Today().Subtract(CType(drv("DateOfBirth"), System.DateTime)).Days / 365 <= 15) Then
drv.Row.SetColumnError("DateOfBirth", "Staff must be over 15 in age")
dvTrainingCoursesTaken As DataView =drv.CreateChildView("Staff_TrainingCoursesTaken")
Dim startDate(dvTrainingCoursesTaken.Count) As Date
endDate(dvTrainingCoursesTaken.Count) As Date
row(dvTrainingCoursesTaken.Count) As System.Data.DataRow
Dim i As Int16 = 0
For Each drv2 As DataRowView In dvTrainingCoursesTaken
Dim HasStartDate, HasEndDate As System.Boolean
If TypeOf drv2("CourseName") Is DBNull Then
drv2.Row.SetColumnError("CourseName", "Course Name is Required")
End If
TypeOf drv2("StartDate") Is DBNull Then
drv2.Row.SetColumnError("StartDate", "Start Date is Required")
startDate(i) = CType(drv2("StartDate"), DateTime).Date
HasStartDate =
End If
TypeOf drv2("EndDate") Is DBNull Then
drv2.Row.SetColumnError("EndDate", "End Date is Required")
endDate(i) = CType(drv2("EndDate"), DateTime).Date
HasEndDate =
End If
(HasStartDate And HasEndDate) Then
row(i) = drv2.Row
End If
i = i + 1
For i = 0 To dvTrainingCoursesTaken.Count
For j As Int16 = i + 1 To dvTrainingCoursesTaken.Count
If Not row(i) Is Nothing And Not row(j) Is Nothing And
RangesOverlap(startDate(i), endDate(i), startDate(j), endDate(j))
row(i).SetColumnError("StartDate", "Course Dates cannot overlap")
row(i).SetColumnError("EndDate", "Course Dates cannot overlap")
row(j).SetColumnError("StartDate", "Course Dates cannot overlap")
row(j).SetColumnError("EndDate", "Course Dates cannot overlap")
End If
Return Me.WebForm1_Staff1.HasErrors
End Function

It is very important for a good client experience to return all validation errors together. However it is not enough to return all the errors in one big bunch for the user to wade through. For ease of use it is important to associate the error message with the control containing the data in error. In complex UIs displaying error messages against each control can be messy and confusing. One obvious solution to this is the highlight the control in error and show a tool tip with the error message when the user moves the mouse across the control.

This can be seen in the screen grab below with the "Course Dates cannot overlap" error message. (By the way, in case there's any confusion when looking at this, my local date format is dd/mm/yyyy rather than month first.)

To achieve this result, first we need to bind the ToolTip property for each control to an expression involving the GetError method. This method has the same parameters as the Eval method, but it returns the associated error message rather than the data. It can be seen in two forms below. Firstly we have an example of the top-level "Date Of Birth" TextBox where the first parameter to DataSetBinder.GetError is the DataSet and the second parameter is a dot delimited path that starts with the TableName and finishes with ColumnName. (In this case we are specifying a column in the master table so no interveening relationship names are required.)

<asp:textbox id=TextBox2 style="Z-INDEX: 106; LEFT: 144px; POSITION: absolute; TOP: 160px"
Text='<%# DataSetBinder.Eval(WebForm1_Staff1,"Staff.DateOfBirth","{0:d}") %>'
ReadOnly='<%# Not DataSetBinder.RowExists(WebForm1_Staff1,"Staff") %>'
ToolTip='<%# DataSetBinder.GetError(WebForm1_Staff1,"Staff.DateOfBirth") %>'
CssClass='<%# IIf(DataSetBinder.HasError(WebForm1_Staff1,"Staff.DateOfBirth"),"error","")%>'>

Secondly, here's an example of the "Course Start Date" which is included in a template. Here (just like Eval), the first parameter is Container and the second parameter starts with "DataItem." and finishes with the ColumnName. (Again we don't need interveening relationship names in this particular example.)

<asp:TextBox id=TextBox5 runat="server" Width="130px"
Text='<%# DataSetBinder.Eval(Container,"DataItem.StartDate","{0:d}") %>'
ToolTip='<%# DataSetBinder.GetError(Container,"DataItem.StartDate") %>'
CssClass='<%# IIf(DataSetBinder.HasError(Container,"DataItem.StartDate"),"error","")%>'>

(As an aside notice that the ReadOnly property was not bound for this TextBox. This is because the row will always exist in this case - otherwise the line would not be generated by the DataList.)
Of course the user won't know which controls have an error message tool tip unless we provide visual feedback. This is done by binding the CssClass property to an expression involving the HasError method. As we flag a validation error by setting the style of the apppropriate control to "error" style, appropriate attributes must be set up for this style in our stylesheet, for example:

.error { background-color:#FFC080; border:1px solid }

Overview of DataSetBinder

To achieve all the functionality described above, DataSetBinder only needs a handfull of functions as shown below.

' Return the value of the specified item or the appropriate default if this item doesn't exist
Public Shared Function Eval(ByVal ds As System.Object, ByVal dataMember As System.String) As System.Object
' Return a formatted value of the specified item or the appropriate default
' if this item doesn't exist
Public Shared Function Eval(ByVal ds As System.Object, ByVal dataMember As System.String,ByVal format As System.String) As System.Object
' Return True if the specified Row exists
Public Shared Function RowExists(ByVal ds As System.Object, ByVal dataMember As System.String) As System.Boolean
' Return True if the specified item has an error associated with it
Public Shared Function HasError(ByVal ds As System.Object, ByVal dataMember As System.String) As System.Boolean
' Return the Error Message associated with an item if any
Public Shared Function GetError(ByVal ds As System.Object, ByVal dataMember As System.String) As System.String
' Return True if the specified row has any errors associated with it
Public Shared Function RowHasErrors(ByVal ds As System.Object, ByVal dataMember As System.String) As System.Boolean

Just like DataBinder, it has two versions of Eval- one for unformatted and one for formatted data. As I mentioned these versions don't employ reflection and return default values for situations where data does not exist.
The RowExists method is handy in binding expressions for ReadOnly or Enabled to prevent data input or inappropriate button clicking in situations where a row does not exist to operate on.

Rich feedback on validation failures can be achieved by binding CssStyle and ToolTip using the HasError and GetError methods respectively.

Finally I have included a RowHasErrors method that is not illustated in the example but could be used to flag the lines in a DataList that have validation failures in situations where not all the data is displayed in the line.
I could describe the implementation of these functions in detail but it probably simplest if you download the source and look at it directly. There is less than 150 lines including comments. What a nice surprise it is to achieve so much with so little.

Points of Interest

A demonstration project for the full Staff Information example used in this article. To keep things simple, this example simulates a data tier in an XmlDocument where in reality Microsoft SQLServer or something similar would be employed. It buffers all user input in the ViewState to prevent potentially costly uneccessary trips to the database. All the user input is validated and committed in one go when the Save button is pressed.

If you want to go straight through to using DataSetBinder, you only have to download the source for it and include it in your own project. You are granted unrestricted rights to use this code however you want.

The code released with this article is based on a portion of the AgileStudio product, which extends Visual Studio. Interestingly it took me half an hour to put together the Staff Information example in AgileStudio and a day and a half to add all the extra code to make it standalone.

Check out the free evaluation at which automatically maintains the bindings, datasets and SQL StoreProcs required for a specific user interface (for Windows or Web applications).


If you would like to see a version of DataSetBinder for CSharp, please let me know. I would also like to further explore UIs for robust data validation in a Web Forms environmen