This article gives an overview of data binding in the .NET Framework. Microsoft has beefed up the data binding features considerably in .NET which has made data binding a compelling option to tie your front-end to data sources. I have concentrated on .NET Windows Forms data binding.
What is DataBinding?
DataBinding is a powerful feature provided by the .NET Framework that enables visual elements in a client to connect to a
datasource such as
Arrays, etc. Some of the visual elements in the client can be
Datagrid, etc. A two-way connection is established such that any changes made to the datasource are reflected immediately in the visual element and vice versa.
Below is a graphical description of the concept of databinding:
DataBinding before .NET
In the earlier databinding models, the datasource that could be used was usually limited to a database. All DBMS systems provided their own APIs to help in building GUI applications and quickly bind them to the data. Programmer did not have the flexibility to control the databinding process with the result that most developers avoided the use of databinding.
DataBinding with .NET
The .NET Framework provides a very flexible and powerful approach to databinding and allows the programmer to have a fine control over the steps involved in the whole process. One of the biggest improvements with .NET has been the introduction of databinding to web pages through the use of .NET server-side web controls. Hence, building data driven web applications has been greatly simplified. Please note that this article only deals with data binding in .NET Windows Forms.
Advantages of DataBinding
- Databinding in .NET can be used to write data driven applications quickly. .NET data binding allows you to write less code with fast execution but still get the work done in the best way.
- .NET automatically writes a lot of databinding code for you in the background (you can see it in "Windows Generated Code" section), so the developer does not have to spend time writing code for basic databinding, but still has the flexibility of modifying any code that he would like to. We get the benefits of bound as well as unbound approach.
- Control over the Databinding process by using events. This is discussed in more detail later in the article.
Disadvantages of DataBinding
- More optimized code can be written by using the unbound or traditional methods.
- Complete flexibility can only be achieved by using the unbound approach.
For databinding to take place, data provider and a data consumer should exist so that a synchronized link is established between the two. Data providers contain the data and the data consumers use the data exposed by the data providers and display them.
.NET has expanded the scope of possible data providers. In .NET, any class or component that implements the
IList interface is a valid
DataSource. If a component implements the
IList interface, then it is transformed into an index based collection.
Some of the classes that support the
IList interface in the NET Framework are given below. Please note that any class that implements the
IList interface is a valid data provider.
Please note that
IList interface only allows you to bind at run time. If you want to support
DataBinding at design time, you will have to implement the
IComponent interface as well. Also note that you cannot bind to
DataReaders in Windows Forms (you can in web forms).
The .NET Framework supports simple and complex DataBinding. Simple databinding is supported by controls like
TextBoxes. In simple databinding, only one data value can be displayed by the control at a time. In complex databinding, which is supported by controls like the
DataGrid, more than one data value from the
DataSource can be displayed.
Dataflow during DataBinding
A good understanding of the
dataflow from the control to the datasource is very important. The diagram below gives an overview of the
dataflow and the objects involved.
In .NET, controls can have many properties that can be bound to a
databound property has an associated
Binding object. Since a control can have many
Binding objects, the control has a collection (instance of
ControlBindingsCollection class) of all the
Binding objects. Also remember that different properties of the same control can be bound to different
Binding object talks to a
CurrencyManager or a
PropertyManager classes merit a little explanation, as they are important.
PropertyManager are derived from the base class
BindingManagerBase. The purpose of
BindingManagerBase class is to maintain the concurrency between the
datasource and the control. Of the two classes, the
CurrencyManager is used when the
datasource implements the
IList Interface. Examples of such
CurrencyManager can be used for simple as well as complex databinding. However, the
PropertyManager is used when the
datasource is an instance of a user-defined class. The
Control's property is bound to the property exposed by this object.
PropertyManager can only be used for simple databinding.
As a rule of thumb, if you want your class to be a
datasource, you should use
CurrencyManager when your class is a data container. However, if you are interested in binding a control to properties exposed by your own class, then using a
PropertyManager is easier, since you do not have to implement the
Since a form can contain many controls each binding to a different datasource, a class is needed to manage the
PropertyManager objects. Therefore, each Windows Form in .NET has a default
BindingContext object associated with it. But, you can always create more
BindingContext objects on the form. The
BindingContext object is a collection of
- A control can have many properties that can be bound.
databound property of the control has an associated
Binding objects for a control are contained by the control's
DataBindings property, which is an instance of
databinding object talks to a
PropertyManager are derived from the
BindingContext object is a collection of
- By default, a form contains one
BindingContext object. More
BindingManagerBase objects can be created and added to the
PropertyManager encapsulates the data access to one
The real flexibility and power of
databinding in .NET is realized because the
BindingManagerBase classes supports events. This enables us to change the data passed between the
Control and the
A quick look at the figure below can help you understand this behaviour.
The diagram above depicts how .NET Windows Forms
databinding has been made flexible by making use of the events generated by
Binding object exposes two events:
Format event is triggered twice. First, when the data is pushed from the
datasource to the
control and the second time when the
datasource is changed and data is updated to the
control. The parse event is triggered once when the data is pulled from the
control to the
The Currency Manager (derived from the
BindingManagerBase class) exposes three events:
CurrentChanged is triggered when the bound value changes;
PositionChanged is triggered when the position property has changed and
ItemChanged is triggered when the current item has changed. Please note that the
PropertyManager class supports only 2 events:
These events enable a user to have fine control over the
dataflow from the control to the
datasource and vice versa.
I would like to give an example that will help you in understanding the events of the
Binding class. This problem was actually the reason why I got interested in learning about the intricacies of
databinding and hence the motivation for this article. The problem came when I was trying to bind a
datetime field from SqlServer with a
text property of the
textbox control. Since, SqlServer stores stores the date in "
MM/dd/yyyy hh:mm:ss" format, so the
textbox would display the time along with the date. No matter how much I tried to remove the time portion in the display, I could not. Then, I came across the events of the
Binding class and the solution using events was very easy and elegant.
Dim WithEvents oBinding As Binding
Private Sub Form2_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
oBinding = New Binding("Text", oDt, "GetDateTime")
txt2.DataBindings.Add("Text", oDt, "GetDateTime")
Private Sub oBinding_Format(ByVal sender As Object, ByVal e
As System.Windows.Forms.ConvertEventArgs) Handles oBinding.Format
e.Value = Format(e.Value, "MM/dd/yy")
In the example, there are two
textboxes. One is implicitly bound to the datetime property of an object of my custom class and the other is explicitly bound using a binding object which is declared with "
WithEvents" keyword so that we can handle the events generated during binding and hence control the display of the data. Also, the sample code provides a good example of how to bind your own classes to controls.
- The reason I used my own class as a
datasource is to avoid the dependency on a SQL Server Database
datetime column and therefore make the example self contained. However, the same code can be applied to format the data when the
datasource is populated from SQL Server database. Please refer to the sample code for better understanding of how to use events.
- Added a new C# sample which does the same thing as the VB.NET example
This article has no explicit license attached to it, but may contain usage terms in the article text or the download files themselves. If in doubt, please contact the author via the discussion board below. A list of licenses authors might use can be found here.