If you are familiar with classic ASP, the declarative data binding syntax introduced in ASP.NET will be familiar to you even though the functionality is vastly different. Data binding expressions are the code you see between <%# and %> characters in an ASPX file. The expressions allow you to easily bind controls to data sources, as well as properties, expressions, and results from method calls exposed by the page. While this feature is easy to use, it often causes some confusion about what is allowed and whether it should be employed.
Data binding basics
Data binding expressions link ASP.NET page properties, server control properties, and data sources when the page's DataBind method is called. You can place data binding expressions on the value side of an attribute/value pair in the opening tag of a server control or anywhere in the page. All data binding expressions, regardless of where you place them, must be contained between <%# and %> characters.
When used with data controls (like Repeater, DataGrid, and so forth), the expression parameter is usually a column name from the data source. However, as long as it returns a value, any valid expression may be used. Likewise, the same syntax may be used outside list controls. This includes displaying values on the page or populating control attributes.
Container.DataItem is a runtime alias for the DataItem bound to a specific item. It maps to an individual item from the data source—like one row from a database query or an individual element from an array. The actual data type for the DataItem is determined by the data source. So, if you're dealing with an array of integers, the DataItem will be an integer.
The following list provides a quick review of the VB.NET syntax for various scenarios:
- <%# Container.DataItem %>—An array of string values is returned.
- <%# Container.DataItem("expression") %>—The specific field from a DataView container is returned.
- <%# Container.DataItem.PropertyName %>—The specific string property value of data source is returned.
- <%# CStr(Container.DataItem.PropertyName) %>—Returns a property value converted to its string representation.
When you're using C#, the syntax is a bit different. The following list includes the corresponding C# code for each line in the previous list. Notice the basic syntax is the same, but it changes when property values are returned and converted to the appropriate data type.
- <%# Container.DataItem %>
- <%# ((DataRowView)Container.DataItem)["PropertyName"] %>
- <%# ((ObjectType)Container.DataItem).PropertyName %>
- <%# ((ObjectType)Container.DataItem).PropertyName.ToString() %>
Syntax is consistent when working with page level properties and methods. The syntax remains the same as long as string values are returned. The following list provides some examples:
- <%# propertyName %>—The value for a page level property is returned.
- <asp:ListBox id="lstValues" datasource='<%# propertyName %>' runat="server">—The value retrieved from the page level property (array, collection of objects, etc.) is bound to the data control.
- <%# (objectName.PropertyName) %>—The value of the page level object property is displayed.
- <%# MethodName() %>—The value returned from the page method is displayed.
You may use individual values (albeit properties, method return values, and so forth) on a page using the following syntax:
<%= Value %>
The C# code in Listing A demonstrates data binding in an ASP.NET Web form. It selects employee names and telephone numbers from the SQL Server Northwind Employees table. The values from the query are displayed via an ASP.NET Repeater control. The column values are inserted via data binding, and the form's window title is populated using a method call. In addition, the ItemIndex property of the DataItem is used to display a row number. The ItemIndex property begins with zero, so one is added before it is displayed.
Listing B contains the equivalent VB.NET code. The main difference is the use of parentheses as opposed to brackets in C#. Also, the casting of the rows is not necessary with VB.NET.
Using the Contain.DataItem object can be tedious, since you must be aware of the data type and convert it accordingly for use. Microsoft does provide the DataBinder class to further simplify development.
Working with DataBinder
Microsoft documentation (on MSDN) states the DataBinder class uses reflection to parse and evaluate a data binding expression against an object at runtime. This method allows RAD designers, such as Visual Studio .NET, to easily generate and parse data binding syntax. This method can also be used declaratively on a Web form's page to simplify casting from one type to another.
You can use the Eval method of the DataBinder class to make .NET do the heavy lifting when using data values in an ASP.NET page. The Eval method accepts the previously covered Container.DataItem object; it works hard to figure out the details of the field identified in the expression and displays it accordingly. It has the following syntax:
DataBinder.Eval(Container.DataItem, "field name", "optional formatting")
The DataBinder.Eval approach is great as it pushes work to the system. On the other hand, you should use it with caution, since time and resources are consumed as the system locates the element and determines its object/data type.
Plenty of options
Data binding makes it relatively simple to include data in ASP.NET pages. There are various data binding options available, which include: binding the data to a control and allowing it to decide how it is presented, or choosing declarative data binding to control presentation within the ASP.NET page. In the end, it comes down to your preference, but it is great to have options.
Miss a column?
Check out the .NET Archive, and catch up on the most recent editions of Tony Patton's column.
Tony Patton began his professional career as an application developer earning Java, VB, Lotus, and XML certifications to bolster his knowledge.
Tony Patton has worn many hats over his 15+ years in the IT industry while witnessing many technologies come and go. He currently focuses on .NET and Web Development while trying to grasp the many facets of supporting such technologies in a production environment on a daily basis.