Data Binding Server Controls
Data Binding Overview and Syntax
Binding to Simple Properties
Binding to Collections & Lists
Binding Expressions or Methods
DataBinder.Eval()
Section Summary
Data Binding Overview and Syntax
ASP.NET introduces a new declarative data binding syntax. This extremely flexible syntax permits the developer to bind not only to data sources, but also to simple properties, collections, expressions, and even results returned from method calls. The following table shows some examples of the new syntax.
| Simple property | Customer: <%# custID %> |
| Collection | Orders: <asp:ListBox id="List1" datasource='<%# myArray %>' runat="server"> |
| Expression | Contact: <%# ( customer.First Name + " " + customer.LastName ) %> |
| Method result | Outstanding Balance: <%# GetBalance(custID) %> |
Although this syntax looks similar to the ASP shortcut for Response.Write -- <%= %> -- its behavior is quite different. Whereas the ASP Response.Write shortcut syntax was evaluated when the page was processed, the ASP.NET data binding syntax is evaluated only when the DataBind method is invoked.
DataBind is a method of the Page and all server controls. When you call DataBind on a parent control, it
cascades to all of the children of the control. So, for example, DataList1.DataBind()
invokes the DataBind method on each of the controls in the DataList templates. Calling DataBind on the
Page -- Page.DataBind() or simply DataBind() -- causes all
data binding expressions on the page to be evaluated. DataBind is commonly called from the Page_Load event, as shown in the following example.
Protected Sub Page_Load(Src As Object, E As EventArgs)
DataBind()
End Sub
You can use a binding expression almost anywhere in the declarative section of an .aspx page, provided it evaluates to
the expected data type at run time. The simple property, expression, and method examples above display text to
the user when evaluated. In these cases, the data binding expression must evaluate to a value of type String.
In the collection example, the data binding expression evaluates to a value of valid type for the DataSource
property of ListBox. You might find it necessary to coerce the type of value in your binding expression to produce
the desired result. For example, if count is an integer:
Number of Records: <%# count.ToString() %>
Binding to Simple Properties
The ASP.NET data binding syntax supports binding to public variables, properties of the Page, and properties of other controls on the page.
The following example illustrates binding to a public variable and simple property on the page. Note that these values are initialized before DataBind() is called.
VB DataBind1.aspx
[Run Sample] |
[View Source]
The following example illustrates binding to a property of another control.
List server controls like DataGrid, ListBox and HTMLSelect use a collection as a data source. The following
examples illustrate binding to usual common language runtime collection types. These controls can bind only to
collections that support the IEnumerable, ICollection, or IListSource interface.
Most commonly, you'll bind to ArrayList, Hashtable, DataView and DataReader.
The following example illustrates binding to an ArrayList.
The following example illustrates binding to a DataView. Note that the DataView class is defined in the System.Data
namespace.
The following example illustrates binding to a Hashtable.
Often, you'll want to manipulate data before binding to your page or a control. The following example illustrates
binding to an expression and the return value of a method.
The ASP.NET framework supplies a static method that evaluates late-bound data binding expressions and optionally
formats the result as a string. DataBinder.Eval is convenient in that it eliminates much of the explicit
casting the developer must do to coerce values to the desired data type. It is particularly useful when
data binding controls within a templated list, because often both the data row and the data field
must be cast.
Consider the following example, where an integer will be displayed as a currency string. With the
standard ASP.NET data binding syntax, you must first cast the type of the data row in order to retrieve the
data field,
This syntax can be complex and difficult to remember. In contrast, DataBinder.Eval is simply a method with
three arguments: the naming container for the data item, the data field name, and a format string.
In a templated list like DataList, DataGrid, or Repeater, the naming container is always
The format string argument is optional. If it is omitted, DataBinder.Eval returns a value of type object, as shown in the following example.
It is important to note that DataBinder.Eval can carry a noticeable performance penalty over the
standard data binding syntax because it uses late-bound reflection. Use DataBinder.Eval judiciously, especially when string
formatting is not required.
VB DataBind2.aspx
[Run Sample] |
[View Source]
Binding to Collections and Lists
VB DataBind3.aspx
[Run Sample] |
[View Source]
VB DataBind4.aspx
[Run Sample] |
[View Source]
VB DataBind5.aspx
[Run Sample] |
[View Source]
Binding Expressions or Methods
VB DataBind6.aspx
[Run Sample] |
[View Source]
DataBinder.Eval
IntegerValue. Next, this is passed as an argument to the String.Format method.
<%# String.Format("{0:c}", (CType(Container.DataItem, DataRowView)("IntegerValue"))) %>
Container.DataItem. Page is another naming container that can be used with
DataBinder.Eval.
<%# DataBinder.Eval(Container.DataItem, "IntegerValue", "{0:c}") %>
<%# CType(DataBinder.Eval(Container.DataItem, "BoolValue"), Boolean) %>
VB DataBind7.aspx
[Run Sample] |
[View Source]