Visual Studio 2005 Windows Forms DataBinding FAQ Table of Contents
Visual Studio 2005 DataBinding FAQ 1
General 2
Q. What Data Binding content is available for the Go-To-Market effort ? 2
Q. What is Data Binding? 3
Q. What is Change Notification and why is it important? 11
Simple Data Binding 15
Q. Why can’t I Tab out of my Control when using Data Binding? 15
Q. Why can’t I close my Form when using DataBinding? 17
Q. How can I get a CheckBox control to immediately update the data source when its value changes? 18
Q. Why doesn’t DataSourceUpdateMode.OnPropertyChanged work for ADO.NET data sources? 18
Q. How can I use simple binding to display multiple data source properties? 19
Q. Why doesn’t my DataGrid control stay in sync with my TextBox Control? 19
ComboBox 20
Q. What are the DisplayMember and ValueMember? 20
Q. How do I setup a ComboBox to bind to a Lookup table? 20
Q. How can I add a “null” or “DBNull” entry to my bound ComboBox? 21
Q. How can I get the ComboBox to display multiple data source properties? 21
Q. Why is my ComboBox slow to load when data binding? 22
New Features in VS 2005 22
Q. What is a BindingSource and why do I need it? 22
Q. What is a BindingNavigator? 25
Q. What is BindingList<T>? 25
Q. What is INotifyPropertyChanged? 25
General
Q. What Data Binding content is available for the Go-To-Market effort ?
The following content is available:
Data Binding FAQ – this document.
Data Binding Overview Presentation – “Data Binding in Windows Forms.ppt”
FAQ and Demo Samples - Brief sample applications which demonstrate specific data binding features. These samples are discussed in detail in this document. C# and VB Source code is available in the Data Binding Go To Market folder.
BindingListNotification (INPC)
BindingListNotification (No INPC)
ComboBoxBinding
CurrencyAndBindingContext
DataBinding Intro
ListChangeNotification
MultiColumnSimpleBinding
OnPropertyChangedBinding
PropertyChangeNotification
SimpleBindingTabIssue
NullableDateTimeSample
General Samples – NY Foods application which demonstrates using the DataGridView, DGV custom CellPainting, BindingSource and BackgroundWorker controls. C# and VB Source code is available in the Data Binding Go To Market folder.
Interface Samples – Demonstrates implementing specific interfaces to facilitate data binding. C# and VB Source code is available in the Data Binding Go To Market folder.
IBindableComponent
ICustomTypeDescriptor
IDataErrorInfo
IEditableObject
IListSource
INotifyPropertyChanged
ITypedList
Q. What is Data Binding?
From a Windows Forms perspective, “Data Binding” is a general mechanism to bind data to a user interface element (Control). There are two broad types of data binding in windows forms: simple and complex.
Simple Binding
Simple binding is a general way to bind a property on a user interface element (Control) to a property on an instance of a type (object). For example, if a developer had an instance of a Customer type they could bind the Customer “Name” property to the “Text” property of a TextBox. When “binding” these two properties, changes to the TextBox.Text property will be propagated to the Customer.Name property and changes to the Customer.Name property will be propagated to the TextBox.Text property. Windows Forms simple binding supports binding to any public or internal .NET Framework property.
Sample: Simple Binding to a Business Object (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 3 TextBoxes to the Form (textBox1, textBox2 and textBox3)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Create a customer instance (use the Customer type below)
******************************************************************/
Customer cust = new Customer(0, "Mr. Zero", 10.0M);
/*******************************************************************
* Bind textBox1, textBox2 and textBox3
******************************************************************/
this.textBox1.DataBindings.Add("Text", cust, "ID", true);
this.textBox2.DataBindings.Add("Text", cust, "Name", true);
this.textBox2.DataBindings.Add("Text", cust, "Rate", true);
Customer Business Object (VS 2005):
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a new C# Class file to your project and name it “Customer.cs”
* Replace the automatically generated Customer class with the
* following Customer class.
******************************************************************/
public class Customer
{
/* Private variables */
private int _id;
private string _name;
private Decimal _rate;
/* Constructor */
public Customer()
{
this.ID = -1;
this.Name = string.Empty;
this.Rate = 0.0M;
}
public Customer(int id, string name, Decimal rate)
{
this.ID = id;
this.Name = name;
this.Rate = rate;
}
/* Public API */
public int ID
{
get { return _id; }
set { _id = value; }
}
public string Name
{
get { return _name; }
set { _name = value; }
}
public Decimal Rate
{
get { return _rate; }
set { _rate = value; }
}
}
Complex Binding
Complex binding is a way to bind a list based user interface element (e.g. ComboBox, Grid) to a list of data instances (e.g. DataTable). Like simple binding, complex binding is generally two-way in that changes to the user interface element are propagated to the data list and changes to the data list are propagated to the user interface element. Windows Forms complex binding supports binding to data lists that support the IList interface (or IEnumerable when using a BindingSource component).
Sample: Complex Binding (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a DataGridView to the Form (dataGridView1)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Create a list of customers. The list instance is named blc.
* Note: Customer has properties ID, Name and Rate
******************************************************************/
BindingList<Customer> blc = new BindingList<Customer>();
blc.Add(new Customer(0, "Mr. Zero", 10.0M));
blc.Add(new Customer(1, "Mrs. One", 15.0M));
blc.Add(new Customer(2, "Dr. Two", 20.0M));
/*******************************************************************
* Bind the DataGridView to the list of Customers using Complex
* binding (customer business type is shown above).
******************************************************************/
this.dataGridView1.DataSource = blc;
Using Simple Binding with a List
Simple binding can take two forms: property to property binding (the simple binding described above) as well as property to “property on an item in a list” binding. Property to “property on an item in a list” binding is identical in form to Property to Property binding with the exception that the data source is a list of items rather than a single item (e.g. BindingList<Customer> rather than Customer). When using simple binding to bind to a list, the Windows Forms data binding runtime will bind the user interface property to a property on an item contained by the list. By default, the runtime will bind to the first item in the list (e.g. binds “TextBox.Text” to Customers[0].Name). If this same list is bound to another control using complex binding (see below), the windows forms runtime will automatically synchronize the simple bound property with the currently selected item in the complex control. For example, a developer can use simple binding to bind the “Text” property on a TextBox to the “Name” property on a Customer list. They can then use complex binding to bind the same list to a Grid control. When they do this, as they select different items in the Grid control, the Text property on the TextBox will automatically re-bind to the currently selected item in the Grid (i.e. the TextBox will show the “Name” of the currently selected Customer”). In Windows Forms, keeping different bound items synchronized is called “currency management”. The core Windows Forms currency management engine is implemented by a type called “CurrencyManager”.
Sample: Simple Binding to a List (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a DataGridView to the Form (dataGridView1)
* Add 3 TextBoxes to the Form (textBox1, textBox2 and textBox3)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Create a list of customers. The list instance is named blc.
* Note: Customer has properties ID, Name and Rate
******************************************************************/
BindingList<Customer> blc = new BindingList<Customer>();
blc.Add(new Customer(0, "Mr. Zero", 10.0M));
blc.Add(new Customer(1, "Mrs. One", 15.0M));
blc.Add(new Customer(2, "Dr. Two", 20.0M));
/*******************************************************************
* Bind the DataGridView to the list of Customers using Complex
* binding (customer business type is shown above).
******************************************************************/
this.dataGridView1.DataSource = blc;
/*******************************************************************
* Bind the business object list to the TextBoxes. This uses simple
* binding of the form "binding to a property on an item in a list".
******************************************************************/
this.textBox1.DataBindings.Add("Text", blc, "ID", true);
this.textBox2.DataBindings.Add("Text", blc, "Name", true);
this.textBox3.DataBindings.Add("Text", blc, "Rate", true);
The Windows Forms data binding engine does more than keep properties and lists synchronized; it provides common services to help simplify this process. The data binding engine provides the following services:
Type Conversion
If required, Windows Forms will perform type conversion as part of the binding process. For example, if an integer property on a business object (e.g. Customer.ID) is bound to a string property on a Control (e.g. TextBox.Text) the data binding runtime will convert the integer value to/from the string value. Windows Forms uses TypeConverters, IFormattable and IConvertible to perform the type conversion.
Sample: Type Conversion (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a TextBox to the Form (textBox1)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Data Source setup:
*
* Create a Table named Numbers and add 3 columns
* ID: int
* Name: string
* Cost: Decimal
******************************************************************/
/*******************************************************************
* A DataTable is an ADO.NET list type that represents a relational
* table.
******************************************************************/
DataTable _dt;
_dt = new DataTable("Numbers");
_dt.Columns.Add("ID", typeof(int));
_dt.Columns.Add("Name", typeof(string));
_dt.Columns.Add("Cost", typeof(decimal));
_dt.Rows.Add(0, "Zero", 10.0M);
_dt.Rows.Add(1, "One", 11.1M);
_dt.Rows.Add(2, "Two", 12.2M);
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.ID (integer)
* The binding runtime will handle type conversion between integer
* and string
******************************************************************/
this.textBox1.DataBindings.Add("Text", _dt, "ID", true);
Formatting
Windows Forms binding supports formatting of the target data using .NET framework format strings. For example, when binding a Decimal property on a business object (e.g. Order.Total) to a string property on a Control (e.g. TextBox.Text) a format string (e.g. “c”) can be specified such that the value is displayed as a locale dependent currency value (e.g. $1.10). Windows Forms leverages IFormattable for string formatting.
In addition to standard format strings, simple binding provides an eventing model that allows developers to plug in their own custom formatting (Binding.Format event) and parsing (Binding.Parse event) logic.
Sample: Formatting (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 2 TextBoxes to the Form (textBox1 and textBox2)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Data Source setup:
*
* Create a Table named Numbers and add 3 columns
* ID: int
* Name: string
* Cost: Decimal
******************************************************************/
DataTable _dt;
_dt = new DataTable("Numbers");
_dt.Columns.Add("ID", typeof(int));
_dt.Columns.Add("Name", typeof(string));
_dt.Columns.Add("Cost", typeof(decimal));
_dt.Rows.Add(0, "Zero", 10.0M);
_dt.Rows.Add(1, "One", 11.1M);
_dt.Rows.Add(2, "Two", 12.2M);
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.ID (integer)
* The binding runtime will handle type conversion between integer
* and string
******************************************************************/
this.textBox1.DataBindings.Add("Text", _dt, "ID", true);
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.Cost
* The binding runtime will display the value as Currency ($value.00)
*
* Note that this manually creates and adds the Binding to the
* control’s DataBinding collection rather than using the
* DataBindings.Add overload.
******************************************************************/
Binding cb = new Binding("Text", _dt, "Cost", true);
/* .NET Framework Currency format string */
cb.FormatString = "c";
/* Add the binding to the Textbox */
this.textBox2.DataBindings.Add(cb);
Error Handling
Windows Forms data binding integrates with the Windows Forms ErrorProvider control. When using the ErrorProvider and if a simple data binding operation fails, the ErrorProvider control will provide visual feedback (an error icon) on the user interface element that experienced the failure. The ErrorProvider looks for exceptions that occur during binding and will additionally report IDataErrorInfo information on data sources that support this interface.
Sample: Error Handling (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 2 TextBoxes to the Form (textBox1 and textBox2)
* Add an ErrorProvider to the Form (errorProvider1)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* Data Source setup:
*
* Create a Table named Numbers and add 3 columns
* ID: int
* Name: string
* Cost: Decimal
******************************************************************/
DataTable _dt;
_dt = new DataTable("Numbers");
_dt.Columns.Add("ID", typeof(int));
_dt.Columns.Add("Name", typeof(string));
_dt.Columns.Add("Cost", typeof(decimal));
_dt.Rows.Add(0, "Zero", 10.0M);
_dt.Rows.Add(1, "One", 11.1M);
_dt.Rows.Add(2, "Two", 12.2M);
/*******************************************************************
* Set up the ErrorProvider:
*
* Bind it to the same data source used by the TextBoxes.
******************************************************************/
this.errorProvider1.DataSource = _dt;
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.ID (integer)
* The binding runtime will handle type conversion between integer
* and string
******************************************************************/
this.textBox1.DataBindings.Add("Text", _dt, "ID", true);
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.Cost
* The binding runtime will display the value as Currency ($value.00)
*
* Note that this manually creates and adds the Binding to the
* control’s DataBinding collection rather than using the
* DataBindings.Add overload.
******************************************************************/
Binding cb = new Binding("Text", _dt, "Cost", true);
/* .NET Framework Currency format string */
cb.FormatString = "c";
/* Add the binding to the Textbox */
this.textBox2.DataBindings.Add(cb);
Currency Management and BindingContext
Currency Management
One of the most important services provided by Windows Forms data binding is currency management. In the context of Windows Forms data binding, currency does not have any monetary connotations; rather it refers to maintaining and synchronizing a “current item” for a list. In Windows Forms, currency management is provided by a type called “CurrencyManager”. The CurrencyManager is a sub-class of an abstract base type called “BindingManagerBase”. CurrentManager provides a set of events including “CurrentChanged” and “PositionChanged” that allows both Controls and developers to monitor changes in “currency”. In addition the CurrencyManager provides properties such as “Position”, and “Current” to allow Controls and developers to set and retrieve the current item (position). A key aspect of Windows Forms data binding is that currency is not maintained by a control such as a DataGrid – rather it is maintained by an instance of a CurrencyManager that is shared between multiple controls.
Binding Context
When using simple list binding (see Simple List Binding) the simple bound control needs to synchronize to the “current item” of its data source. In order to do this, the binding needs to get the “Current” item for the CurrencyManager associated with the binding. The binding gets a CurrencyManager for its data source through its Control’s “BindingContext” property (a Control typically gets its BindingContext from the parent Form). The “BindingContext” is a per-Form cache of CurrencyManagers (more precisely, BindingContext is a cache of BindingManagerBase instances and BindingManagerBase is the base class of CurrencyManager).
As an example, suppose a developer had a list of Customers bound to a DataGrid control (e.g. DataGrid.DataSource is set to a list of Customers). In addition, the developer had a simple control, such as a TextBox, bound to the same list (e.g. TextBox.Text is bound to the property “Name” on the Customer list using Simple List Binding). When clicking on an item in the DataGrid, the DataGrid will make the clicked item the currently selected item. The DataGrid does this by first asking its BindingContext for the BindingManagerBase (CurrencyManager) of its data source (list). The BindingContext returns the cached BindingManagerBase (and creates one if it doesn’t exit). The DataGrid will use the BindingManagerBase API to change the “Current” item (it does this by setting the CurrencyManager Position property). When a simple binding is constructed binding it will get the BindingManagerBase (CurrencyManager) associated with its data source. It will listen to change events on the BindingManagerBase and synchronize updates to its bound property (e.g. “Text” property) with updates to the BindingManagerBase “Current” item. The key to this working correctly is that both the DataGrid and the TextBox need to be using the same CurrencyManager (BindingManagerBase). If they are using different CurrencyManagers, then the simple bound property will not correctly update when the DataGrid item changes.
As previously mentioned, Controls (and developers) can get a BindingManagerBase for a data source using a Controls BindingContext. When requesting a BindingManagerBase from the BindingContext, the BindingContext will first look in its cache for the requested BindingManagerBase. If the BindingManagerBase doesn’t exist in the cache, then the BindingContext will create and return a new one (and add it to the cache). The BindingContext is typically global per form (child controls delegate to their parents BindingContext) so BindingManagerBases (CurrencyManagers) are typically shared across all Controls on a Form. The BindingContext has two forms:
/* Get a BindingManagerBase for the given data source */
bmb = this.BindingContext[dataTable];
/* Get a BindingManagerBase for the given data source and data member */
bmb = this.BindingContext[dataSet, "Numbers"];
The first form is commonly used when getting a BindingManagerBase for a list such as an ADO.NET DataTable. The second form is used to get a BindingManagerBase for a parent data source that has child lists (e.g. DataSet with child DataTables). One of the most confusing aspects of BindingContext is using the different forms to specify the same data source you result in two different BindingManagerBases instances. This is by far and away the most common reason Controls bound to the same data source don’t synchronize (Controls use BindingContext to get a BindingManagerBase).
Sample: Control Synchronization (VS 2005) (VS Projects: CurrencyAndBindingContext and DataBinding Intro)
/* Create a DataSet with 1 DataTable */
DataSet dataSet = new DataSet();
DataTable dataTable = dataSet.Tables.Add("Numbers");
dataTable.Columns.Add("ID", typeof(int));
dataTable.Columns.Add("Name", typeof(string));
dataTable.Rows.Add(0, "Zero");
dataTable.Rows.Add(1, "One");
/*******************************************************************
* Bind the first DataGridView and TextBox to the “Numbers” table in
* dataSet. The DataGridView will use BindingContext to get a
* CurrencyManager for the data source. DataGridView1 will use
* the following form of BindingContext:
*
* bmb = BindingContext[dataSet, “Numbers”];
*
* The textBox1’s Text Binding will also get a BindingManagerBase
* and will use the following BindingContext form:
*
* bmb = BindingContext[dataSet, “Number”];
*
* Therefore both dataGridView1 and textBox1 will share the same
* BindingManagerBase (CurrencyManager).
*******************************************************************/
this.dataGridView1.DataSource = dataSet;
this.dataGridView1.DataMember = "Numbers";
this.textBox1.DataBindings.Add("Text", dataSet, "Numbers.Name", true);
/*******************************************************************
* The variable “dataTable” contains the “Numbers” table. Although
* the above DataGridView and TextBox bound to this table using
* “DataSource” and “DataMember” form, they could have bound to the
* same Table (and data) by binding directly to “dataTable” as shown
* below. When doing this, DataGridView2 will use the following form
* of BindingContext:
*
* bmb = BindingContext[dataTable];
*
* The textBox12’s Text Binding will use the following BindingContext
* form:
*
* bmb = BindingContext[dataTable];
*
* Therefore both dataGridView2 and textBox2 will share the same
* BindingManagerBase (CurrencyManager) however they will not
* share the same CurrencyManager since they used a different form
* to specify their bindings.
*******************************************************************/
this.dataGridView2.DataSource = dataTable;
this.textBox2.DataBindings.Add("Text", dataTable, "Name", true);
Controlling the Binding Operation
The Windows Forms simple binding type (System.Windows.Forms.Binding) allows developers to control how and when a change to user interface element updates a bound data source property as well as how and when a change to a data source property updates the user interface element. For example, if a developer bound the “Name” property on a Customer instance to the “Text” property on a TextBox control, the developer can specify when changes to the user interface element (Control) are propagated to the data source. Currently supported options are during validation of the TextBox (when user Tabs off the TextBox – this is the default), when any changes are made to the Text value or never. The developer can also control when data source changes update the bound user interface element. Currently supported options are when the data source property changes (the default) and never. Note that developers can use the combination of “never” and calling the Binding API (ReadValue/WriteValue) to provide their own explicit rules for synchronizing data between the data source property and the user interface element.
Sample: Explicit Binding (VS 2005) (VS Project: DataBinding Intro)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 3 TextBoxes to the Form (textBox1, textBox2 and textBox2)
* Add an ErrorProvider to the Form (errorProvider1)
* Add a Button to the Form (button1)
* Add the code below to the Form.Load event
******************************************************************/
/*******************************************************************
* DataSource setup:
*
* Create a Table named Numbers and add 3 columns
* ID: int
* Name: string
* Cost: Decimal
******************************************************************/
DataTable _dt;
_dt = new DataTable("Numbers");
_dt.Columns.Add("ID", typeof(int));
_dt.Columns.Add("Name", typeof(string));
_dt.Columns.Add("Cost", typeof(decimal));
_dt.Rows.Add(0, "Zero", 10.0M);
_dt.Rows.Add(1, "One", 11.1M);
_dt.Rows.Add(2, "Two", 12.2M);
/*******************************************************************
* Set up the ErrorProvider:
*
* Bind it to the same data source used by the TextBoxes.
******************************************************************/
this.errorProvider1.DataSource = _dt;
/*******************************************************************
* Bind TextBox.Text (string) to Numbers.ID (integer)
*
* Set DataSourceUpdateMode to OnPropertyChanged. This will
* cause the changes in the TextBox.Text value to be immediately
* set to the Data Source property.
*
* Note, in this mode the ErrorProvider will immediately display an
* error rather than display only an error when the user Tabs
* off the TextBox.
******************************************************************/
this.textBox1.DataBindings.Add("Text", _dt, "ID", true,
DataSourceUpdateMode.OnPropertyChanged);
/*******************************************************************
* Bind TextBox.Text to Form.Size (in this scenario, Form is the data source)
* Do not update the DataSource (Form) with Control changes
******************************************************************/
Binding sizeBinding = new Binding("Text", this, "Size", true,
DataSourceUpdateMode.Never);
this.textBox2.DataBindings.Add(sizeBinding);
/*******************************************************************
* Setup the Button.Click to explicitly update the DataSource (Form.Size).
*
* Use anonymous delegate to keep the code cleaner
******************************************************************/
this.button1.Click += delegate(object button, EventArgs args)
{
sizeBinding.WriteValue();
};
Q. What is Change Notification and why is it important?
Property Change Notification
The single most important concept to understand about Windows Forms data binding is that it is driven off of change notification. What this means is that Windows Forms will not update a user interface element (Control) unless that data source notifies the Windows Forms data binding runtime that the data has changed (by providing a notification event). In the case of simple property to property binding, the data source needs to provide property change notification by either providing a “PropertyName”Changed event for the property or by implementing the INotifyPropertyChanged interface. The INotifyPropertyChanged interface is new in VS 2005 and can be used with BindingList<T> to create bindable lists (described below).
Sample: Simple Binding without Change Notification (VS 2005) (VS Project: PropertyChangeNotification)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a Label to the Form (label1)
* Add the following code to the Form.Load event
******************************************************************/
CurrentTime currentTime = new CurrentTime();
/*******************************************************************
* Bind Label.Text (string) to CurrentTime.Now
* Note: the Label will not update when “Now” changes because Now
* does not provide change notification.
******************************************************************/
Binding binding = new Binding("Text", currentTime, "Now", true);
binding.FormatString = "MM/dd/yyyy hh:MM:ss";
this.label1.DataBindings.Add(binding);
/***********************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add a new class file to your project named "CurrentTime"
* Add the following code to the class implementation
**********************************************************************/
public class CurrentTime
{
System.Windows.Forms.Timer _timer;
public CurrentTime()
{
/***************************************************************
* Use a timer to keep track of the current timer
***************************************************************/
_timer = new System.Windows.Forms.Timer();
/***************************************************************
* Update the time every second
***************************************************************/
_timer.Interval = 1000;
_timer.Tick += delegate { this.Now = DateTime.Now; };
_timer.Start();
}
/*******************************************************************
* Use a timer to keep track of the current time
*******************************************************************/
private DateTime _now = DateTime.Now;
/*******************************************************************
* No Change Notification – bound controls will not update
*******************************************************************/
public DateTime Now
{
get { return _now; }
private set
{
if (_now != value)
{
_now = value;
}
}
}
}
Sample: Simple Binding with “Property”Changed Change Notification (VS 2005) (VS Project: PropertyChangeNotification)
/***********************************************************************
* Setup (using the Visual Studio Form designer):
*
* Use the Same Form as in the sample above but change the “CurrentTime”
* type to provide Change notification for the “Now” property. This sample
* uses the “Property”Changed pattern. The label Text value will correctly
* update in this sample.
***********************************************************************/
public class CurrentTime
{
System.Windows.Forms.Timer _timer;
public CurrentTime()
{
/***************************************************************
* Use a timer to keep track of the current timer
***************************************************************/
_timer = new System.Windows.Forms.Timer();
/***************************************************************
* Update the time every second
***************************************************************/
_timer.Interval = 1000;
_timer.Tick += delegate { this.Now = DateTime.Now; };
_timer.Start();
}
/*******************************************************************
* Use a timer to keep track of the current time
*******************************************************************/
private DateTime _now = DateTime.Now;
/*******************************************************************
* Property Change Notification fired – bound UI elements will
* update when this property changed
*
* This uses the “Property”Changed pattern
*******************************************************************/
public DateTime Now
{
get { return _now; }
private set
{
if (_now != value)
{
_now = value;
OnNowChanged(EventArgs.Empty);
}
}
}
/*******************************************************************
* Provide a “Property”Changed event
*******************************************************************/
public event EventHandler NowChanged;
protected virtual void OnNowChanged(EventArgs e)
{
if (null != NowChanged)
{
NowChanged(this, e);
}
}
}
Sample: Simple Binding with INotifyPropertyChanged Change Notification (VS 2005) (VS Project: PropertyChangeNotification)
/***********************************************************************
* Setup (using the Visual Studio Form designer):
*
* Use the Same Form as in the sample above but replace with this version
* of the CurrentTime Type.
*
* This sample implements System.ComponentModel.INotifyPropertyChanged.
* The label Text value will correctly update in this sample.
**********************************************************************/
using System.ComponentModel;
public class CurrentTime : INotifyPropertyChanged
{
System.Windows.Forms.Timer _timer;
public CurrentTime()
{
/***************************************************************
* Use a timer to keep track of the current timer
***************************************************************/
_timer = new System.Windows.Forms.Timer();
/***************************************************************
* Update the time every second
***************************************************************/
_timer.Interval = 1000;
_timer.Tick += delegate { this.Now = DateTime.Now; };
_timer.Start();
}
/*******************************************************************
* Use a timer to keep track of the current time
*******************************************************************/
private DateTime _now = DateTime.Now;
/*******************************************************************
* Property Change Notification fired – bound UI elements will
* update when this property changed
*
* This uses INotifyPropertyChanged
*******************************************************************/
public DateTime Now
{
get { return _now; }
private set
{
if (_now != value)
{
_now = value;
OnPropertyChanged(“Now”);
}
}
}
/*******************************************************************
* Provide the INotifyPropertyChanged.PropertyChanged event
*******************************************************************/
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName)
{
OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (null != PropertyChanged)
{
PropertyChanged(this, e);
}
}
}
List Change Notification
Sample: BindingList with INotifyPropertyChanged Change Notification (VS 2005) (VS Project: BindingListNotification (INPC))
Sample: BindingList without INotifyPropertyChanged Change Notification (VS 2005) (VS Project: BindingListNotification (no INPC))
Sample: ListChangeNotification
When the data source is a list (complex or simple bound list), the data source needs to provide both list and property change notification via the IBindingList interface. List change notification is used to notify user interface elements when an item has been added, removed or deleted from the list. Property change notification on a list is used to notify user interface elements that a property on an item in the list has changed (e.g. the “Name” property on Customer instance in the nth position of the list changed). One key aspect of list binding in Windows Forms is that IBindingList provides both list based change notification and property based change notification. In other words, and this is a key point, Windows Forms controls that are bound to a list will not listen to property change notification provided by items within the list – rather Windows Forms requires the list to provide this notification on behalf of the contained items.
Prior to VS 2005, implementing IBindingList required a tight coupling between the list and contained list items as the contained items needed to tell the list when properties on them changed. In VS 2005, this has been simplified with the introduction of BindingList<T> and the INotifyPropertyChanged interface. BindingList<T> is a generic implementation of the IBindingList interface that will automatically translate child INotifyPropertyChanged events into IBindingList.ListChanged events.
Note that the experience of binding to a list based data source that is not an IBindingList may be improved if the list is bound through a BindingSource. See the BindingSource topic below for more information on BindingSource.
Q. Why can’t I Tab out of my Control when using Data Binding?
By default, simple binding updates a bound data source property value as part of Control validation. Control validation occurs when a Control loses focus which occurs when a user Tabs or Clicks off a Control (see Controlling the Binding Operation for more information). If an error occurs as part of the validation process, Windows Forms will cancel the validation and focus will not move to the next Control. For example, assume you bind a TextBox “Text” property to an integer property on a data source. When s user Tabs off the TextBox, validation occurs and the data binding engine (Binding type) will attempt to update the data source property with the bound Control value (TextBox.Text). If an error (exception) occurs as part of the data source update, the default behavior of the binding engine is to fail validation which prevents focus from leaving the TextBox.
It is important to note that if an error occurs then the binding engine must assume that the value displayed to the user (TextBox.Text) is inconsistent with the value in the data source property. In this scenario it is important to neither make it appear as if the binding was successful (silently fail) or display an intrusive dialog. For this reason, the default behavior is to “trap” the user on the Control until they enter a successful value.
Sample: Using an ErrorProvider and ToolTip to show error status (VS 2005) (VS Project: SimpleBindingTabIssue)
In VS 2005 there are two ways you can provide feedback to a user when a binding error occurs. The easiest way is to add an ErrorProvider to the Form and set ErrorProvider.DataSource to the same data source used by the Binding. In addition, you can also add a handler to the BindingComplete event for the Binding and write your own customer error handling logic. In the sample below, the custom logic shows a ToolTip:
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 1 TextBox to the Form (textBox1)
* Add 2 CheckBoxes to the Form (showErrorToolTipCB
* and showErrorProviderCB)
*
* Add the following public property to the Form class:
*
* private int _intValue;
*
* public int IntegerValue
* {
* get { return _intValue; }
* set { _intValue = value; }
* }
*
* Add the following code to the Form.Load event:
******************************************************************/
ToolTip errorTT = new ToolTip();
ErrorProvider ep = new ErrorProvider(this);
Binding tbBinding = new Binding("Text", this, "IntegerValue", true);
/* Add binding */
this.textBox1.DataBindings.Add(tbBinding);
/* Hook BindingComplete to allow navigation */
tbBinding.BindingComplete += delegate(object bind, BindingCompleteEventArgs args)
{
if ((this.showErrorToolTipCB.Checked) && !String.IsNullOrEmpty(args.ErrorText))
{
/* Show ToolTip */
errorTT.Show(args.ErrorText, this.textBox1, 2000);
}
};
this.showErrorProviderCB.CheckedChanged += delegate
{
ep.DataSource = (this.showErrorProviderCB.Checked ? this : null);
};
/* Initialize ToolTip */
errorTT.IsBalloon = true;
errorTT.ToolTipTitle = "Binding Error:";
/* Initialize ErrorProvider */
ep.BlinkStyle = ErrorBlinkStyle.NeverBlink;
}
Sample: Allowing a user to Tab off a Control when a binding error occurs (VS 2005) (VS Project: SimpleBindingTabIssue)
Control validation occurs when a Control loses focus (see Controlling the Binding Operation for more information). When the user Tabs off the TextBox, validation occurs and the data binding engine (Binding type) will attempt and update the data source property with the bound Control value (TextBox.Text). If an exception occurs, validation will fail and the focus will not leave the bound Control. To allow focus to leave, you can add a BindingComplete event handler and set e.Cancel to false:
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 1 TextBox to the Form (textBox1)
*
* Add the following public property to the Form class:
*
* private int _intValue;
*
* public int IntegerValue
* {
* get { return _intValue; }
* set { _intValue = value; }
* }
*
* Add the following code to the Form.Load event:
******************************************************************/
Binding tbBinding = new Binding("Text", this, "IntegerValue", true);
/* Add binding */
this.textBox1.DataBindings.Add(tbBinding);
/* Hook BindingComplete to allow navigation */
tbBinding.BindingComplete += delegate(object bind, BindingCompleteEventArgs args)
{
/* Allow user to Tab off */
args.Cancel = false;
};
}
Q. Why can’t I close my Form when using DataBinding?
By default, simple binding updates a bound data source property value as part of Control validation. Control validation occurs when a Control loses focus (see Controlling the Binding Operation for more information). Validation also occurs when a Form is closed either by using the OS provided close button (the red X on XP platforms) or when explicitly calling Form.Close(). If an exception occurs during data binding, the data binding runtime will force the validation process to fail. If this data binding fails when closing a Form, this will have the affect of preventing the form from closing. In VS 2005, a new cancelable event was adding to Form called FormClosing. This event can be used to force close a Form when validation fails (see sample below).
In cases where you are trying to close a Form via a Close or Cancel button, you will need to use the combination of the “CausesValidation” property and the FormClosing event (see sample below). When you set “CausesValidation” to false on a Control, it will prevent automatic validation from occurring as a result of the Control taking focus. For example, if you have a TextBox and a Button and set the Button.CausesValidation to false, tabbing from the TextBox to the Button will not cause validation to occur on the TextBox (and therefore, simple data binding will not occur on the TextBox).
Sample: Allowing a Form to close when a data binding error occurs (VS 2005) (VS Project: SimpleBindingTabIssue)
/*******************************************************************
* Setup (using the Visual Studio Form designer):
*
* Add 1 TextBox to the Form (textBox1)
* Add 1 Button to the Form (closeBtn)
* Add 2 CheckBoxes to the Form (allowFormCloseCB, allowCloseOnCloseFormCB)
*
* Add the following public property to the Form class:
*
* private int _intValue;
*
* public int IntegerValue
* {
* get { return _intValue; }
* set { _intValue = value; }
* }
*
* Add the following code to the Form.Load event:
******************************************************************/
Binding tbBinding = new Binding("Text", this, "IntegerValue", true);
bool forceClose = false;
/* Add binding */
this.textBox1.DataBindings.Add(tbBinding);
/* Allow Form to Close */
this.FormClosing += delegate(object form, FormClosingEventArgs fargs)
{
if (fargs.Cancel && (this.allowFormCloseCB.Checked || forceClose))
{
/* Allow close */
fargs.Cancel = false;
}
};
/* Allow Form to Close when using the "Close Form" button */
this.allowCloseOnCloseFormCB.CheckedChanged += delegate
{
this.closeBtn.CausesValidation = !this.allowCloseOnCloseFormCB.Checked;
};
/* Exit the application */
this.closeBtn.Click += delegate
{
/* Close the Form */
forceClose = true;
this.Close();
};
Q. How can I get a CheckBox control to immediately update the data source when its value changes?
By default, simple binding updates a bound data source property value as part of Control validation. Control validation occurs when a Control loses focus (see Controlling the Binding Operation for more information). In VS 2005, a new property named DataSourceUpdateMode was added to the Binding type to provide greater flexibility over when a control updates a bound data source property. When this property is set to OnPropertyChanged, it will cause the data source to get updated when the control property value changes rather than on validation (focus change). Note that this only works for control properties that support change notification in the form of the “PropertyName”Changed pattern (see Property Change Notification for more information).
Sample: Updating a data source property when a control property changes (VS 2005) (VS Project: OnPropertyChangedBinding)
You can set the DataSourceUpdateMode for a binding using the VS 2005 designer using the “Formatting and Advanced Binding” dialog. You can set this value in code as shown below:
/* Bind the CheckBox.Checked property to the data source property “Prop” */
/* Update the data source when the Checked property value changes */
cb.DataBindings.Add("Checked", ds, "Prop", true, DataSourceUpdateMode.OnPropertyChanged);
Q. Why doesn’t DataSourceUpdateMode.OnPropertyChanged work for ADO.NET data sources?
When binding to ADO.NET tables using simple list binding, the Windows Forms runtime binds to an instance of an ADO.NET DataRowView. The DataRowView supports row level commit semantics via an interface called IEditableObject (see the IEditableObject section for more information). IEditableObject requires changes to be “committed” prior to the changes being accepted by the data model. When binding to the DataRowView, the DataRowView will update as a result of data binding however it defers change notification until the row has been committed. What this means is that even though the DataRowView has been updated, other controls are not aware of the update and therefore don’t show the updated value. You can work around this by either manually forcing other bound controls to refresh their contents or by explicitly calling EndEdit on the DataRowView.
Sample: Explicitly calling EndEdit with simple binding (VS 2005) (VS Project: OnPropertyChangedBinding)
In VS 2005, a new event named BindingComplete was added to the Binding type to provide general information on the completion state of a binding operation. When using simple binding, you can use this event to call EndEdit to automatically commit changes on an instance that supports IEditableObject (e.g. ADO.NET DataRowView).
/* Bind the CheckBox.Checked property to the data source property “Prop” */
/* Update the data source when the Checked property value changes */
cb.DataBindings.Add("Checked", ds, "Prop", true, DataSourceUpdateMode.OnPropertyChanged);
/* Get the binding – could have manually created and added the binding as well */
Binding adoBinding = cb.DataBindings["Checked"];
/* Force EndEdit for ADO.NET */
adoBinding.BindingComplete += delegate(object binding, BindingCompleteEventArgs args)
{
if ((args.BindingCompleteContext == BindingCompleteContext.DataSourceUpdate) &&
(args.BindingCompleteState == BindingCompleteState.Success))
{
DataRowView drv = (args.Binding.BindingManagerBase.Current as DataRowView);
/* Force ADO.NET to commit the value */
if (null != drv)
{
drv.EndEdit();
}
}
};
Q. How can I use simple binding to display multiple data source properties?
Simple binding does not directly support data source property concatenation however you can use the Binding Format event to concatenate multiple data source properties. To do this you need to add a Binding to the primary property (or one of the data source properties you want to concatenate) and use the Format event to concatenate the multiple property values. Note that although this will generally work as expected, there are times where the Format event may not produce the desired results. Since the binding is bound to a single data source property, the Control will only update when the bound data source property changes. If you need the Control to update when either property changes, then you will need to write additional code to update the Control when the secondary property changes.
Sample: Concatenating data source properties using the Format event (VS 2005) (VS Project: MultiColumnSimpleBinding)
/* Setup binding - bind to Hour */
/* Second would be a better choice but this provides a better example */
/* of the potential issues you can run into with multi-column binding */
this.textBox1.DataBindings.Add("Text", bo, "Hour", true);
/* Add formatting event */
Binding timeBinding = this.textBox1.DataBindings["Text"];
/* Concatenate “Hour”, “Minute” and “Second” properties on the data source */
timeBinding.Format += delegate(object binding, ConvertEventArgs args)
{
// Get the bound object
BusObject bo = ((binding as Binding).BindingManagerBase.Current as BusObject);
if (null != bo)
{
args.Value = string.Format("{0:00}:{1:00}:{2:00}", bo.Hour, bo.Minute, bo.Second);
}
};
Q. Why doesn’t my DataGrid control stay in sync with my TextBox Control?
When two controls using the same data source are not synchronized, it is because they are using different CurrencyManagers (see Currency Management section for more details). There are two common ways in which controls bound to the same data source have different CurrencyManagers: the first is they have specified their data sources using different syntax (this is the more common of the two - see sample below) and the second is they using a different BindingContext.
Sample: Control Synchronization (VS 2005) (VS Project: CurrencyAndBindingContext)
/* Create a DataSet with 1 DataTable */
DataSet dataSet = new DataSet();
DataTable dataTable = dataSet.Tables.Add("Numbers");
dataTable.Columns.Add("ID", typeof(int));
dataTable.Columns.Add("Name", typeof(string));
dataTable.Rows.Add(0, "Zero");
dataTable.Rows.Add(1, "One");
/*******************************************************************
* Bind the first DataGridView and TextBox to the “Numbers” table in
* dataSet. The DataGridView will use BindingContext to get a
* CurrencyManager for the data source. DataGridView1 will use
* the following form of BindingContext:
*
* bmb = BindingContext[dataSet, “Numbers”];
*
* The textBox1’s Text Binding will also get a BindingManagerBase
* and will use the following BindingContext form:
*
* bmb = BindingContext[dataSet, “Number”];
*
* Therefore both dataGridView1 and textBox1 will share the same
* BindingManagerBase (CurrencyManager).
*******************************************************************/
this.dataGridView1.DataSource = dataSet;
this.dataGridView1.DataMember = "Numbers";
this.textBox1.DataBindings.Add("Text", dataSet, "Numbers.Name", true);
/*******************************************************************
* The variable “dataTable” contains the “Numbers” table. Although
* the above DataGridView and TextBox are bound to this table using
* “DataSource” and “DataMember” form, they could have bound to the
* same Table (and data) by binding directly to “dataTable” as shown
* below. When doing this, DataGridView2 will use the following form
* of BindingContext:
*
* bmb = BindingContext[dataTable];
*
* The textBox2’s Text Binding will use the following BindingContext
* form:
*
* bmb = BindingContext[dataTable];
*
* Therefore both dataGridView2 and textBox2 will share the same
* data source however they will not share the same CurrencyManager
* since they used different forms to specify their bindings.
*******************************************************************/
this.dataGridView2.DataSource = dataTable;
this.textBox2.DataBindings.Add("Text", dataTable, "Name", true);
ComboBox
Q. What are the DisplayMember and ValueMember?
You can fill a ComboBox with non-string items such as business objects. By default, the ComboBox will call ToString() on each of the items to generate the display text (visible text). Rather than rely on ToString(), you can have the ComboBox use one of the properties on the contained objects (business object) as the display text. To do this, set the ComboBox.DisplayMember to the property name you want to use for the display text. You can also set the ValueMember to a property on the contained objects that represents the object unique key. You can then use the ComboBox “SelectedValue” property to set the ComboBox selected item via object key.
Sample: ComboBox DisplayMember and ValueMember (VS 2005) (VS Project: ComboBoxBinding)
/* Need to add a using statement for System.Globalization */
/* Bind a ComboBox (culturesCB) to a current framework cultures */
this.culturesCB.DisplayMember = "EnglishName";
this.culturesCB.ValueMember = "LCID";
this.culturesCB.DataSource = CultureInfo.GetCultures(CultureTypes.FrameworkCultures);
/* Set the currently selected item in the ComboBox */
this.culturesCB.SelectedValue = CultureInfo.CurrentCulture.LCID;
Q. How do I setup a ComboBox to bind to a Lookup table?
A common use of a ComboBox in a data bound application is as a lookup based UI control. From a database perspective, a Lookup control is used to provide the “lookup” values for a foreign key. For example, assume you have a customer table with a “StateID” where the “StateID” is a foreign key into a “States” table. From a UI perspective, you’d like to allow the user to select a State via a ComboBox. To do this, you use Complex Binding to bind the ComboBox to the States table (setting the ComboBox.DisplayMember and ComboBox.ValueMember) and use Simple List Binding to bind the ComboBox SelectedValue to the Customer “StateID”.
Sample: ComboBox as a Lookup table (VS 2005) (VS Project: ComboBoxBinding)
/* Create a new Customer (customer has “Name” */
/* and “StateID” properties) */
Customer cust = new Customer("Joe", "WA");
/* Bind the States ComboBox to the states DataTable */
/* Display the "Name" property in the ComboBox */
/* Use the "Code" property as the "Key" *
/* StatesTable contains US state information */
/* Name = full state name */
/* Code = state unique key */
this.statesCB.DisplayMember = "Name";
this.statesCB.ValueMember = "Code";
this.statesCB.DataSource = statesTable;
/* Set the default States ComboBox selected value */
/* to the Customer's StateID ("WA") */
/* This will make the ComboBox show "Washington" */
/* If the States ComboBox is changed, the Customer */
/* StateCode will be automatically updated */
this.statesCB.DataBindings.Add("SelectedValue", cust, "StateID", true);
Q. How can I add a “null” or “DBNull” entry to my bound ComboBox?
When data bound, the Windows Forms ComboBox does not provide a general way to add a “null” or “not selected” value to its items list. The only generally supported way to do this is to add a “null” item to your data source list. Building on the previous states example, this would require an additional “null” row to be manually added to the States table.
Sample: Adding a “null” value to a Lookup based ComboBox (VS 2005) (VS Project: ComboBoxBinding)
/* Create a new Customer */
Customer cust = new Customer("Joe", null);
/* Add null value */
DataRow row = statesTable.NewRow();
/* Enter a null row (ComboBox will show blank) */
row["Name"] = "";
row["Code"] = DBNull.Value;
/* Add the row to DataTable */
statesTable.Rows.Add(row);
/* Bind the States ComboBox to the states DataTable */
this.statesCB.DisplayMember = "Name";
this.statesCB.ValueMember = "Code";
this.statesCB.DataSource = statesTable;
/* Bind the ComboBox SelectedValue to the customer */
/* business object */
this.statesCB.DataBindings.Add("SelectedValue", cust, "StateID", true);
Q. How can I get the ComboBox to display multiple data source properties?
ComboBox binding does not directly support data source property concatenation however you can use the ComboBox Format event to concatenate multiple data source properties.
Sample: Concatenating data source properties using the Format event (VS 2005) (VS Project: ComboBoxBinding)
/* Need to add a using statement for System.Globalization */
/* Bind a ComboBox (culturesCB) to a current framework cultures */
this.culturesCB.ValueMember = "LCID";
this.culturesCB.DataSource = CultureInfo.GetCultures(CultureTypes.FrameworkCultures);
/* Set the currently selected item in the ComboBox */
this.culturesCB.SelectedValue = CultureInfo.CurrentCulture.LCID;
/* Concatenate the IetfLanguageTag and DisplayName properties */
this.culturesCB.Format += delegate(object cb, ListControlConvertEventArgs args)
{
CultureInfo ci = (args.ListItem as CultureInfo);
if (null != ci)
{
args.Value = string.Format("{0}: {1}", ci.IetfLanguageTag, ci.DisplayName);
}
};
Q. Why is my ComboBox slow to load when data binding?
ComboBox loading performance issues are generally related to loading the data multiple times. The two most common scenarios for this are setting the DisplayMember after setting the DataSource or binding the ComboBox prior to filling the DataSource. Setting the DisplayMember after setting the ComboBox DataSource will result in the ComboBox re-loading its internal list. In addition, filling the data source after binding the ComboBox to the data source may result in the ComboBox reloading multiple times.
Q. What is a BindingSource and why do I need it?
The BindingSource component provides a layer of indirection between the underlying data source and the bound UI controls. The usage pattern for BindingSource is for it to be bound to the data source and for the UI controls to be bound to the BindingSource. By sitting between the data source and controls, the BindingSource can provide services on behalf of the data source. The most important services provided by the BindingSource are:
IBindingList services for non-IBindingLists including IEnumerable binding
Windows Forms complex data binding in VS 2005 will work correctly against lists of type IEnumerable when bound through a BindingSource (V1.0 and V1.1 required IList). The BindingSource up-converts all non IBindingList based data sources to IBindingLists. In the case of IEnumerable, the BindingSource will copy all data source elements into an internal list and indirectly binding controls to the internal list.
_bs = new BindingSource();
// Open SQLConnection
conn.Open();
// Get Reader
SqlDataReader reader = cmd.ExecuteReader();
// Binding IEnumerable
_bs.DataSource = reader;
// Close connection
conn.Close();
// Close connection
this.businessDataGridView.DataSource = _bs;
The IBindingList interface’s AddNew() method is called by Controls to add new items to the bound list. There may be times, such as when binding to a list of factory objects, where the list may not be able to create a new instance for the list. In these cases, you can use the extensible AddNew capabilities of the BindingSource to provide your own implementation for AddNew().
public void Initialize()
{
_bs = new BindingSource();
// Add Customers
_bs.Add(new Customer(“555”));
// Binding Simple Control
this.lastNameTextBox.DataBindings.Add(“Text”, _bs, “LastName”, true);
// Binding Simple Control
_bs.AddingNew += new AddingNewEventHandler(BindingSource_AddingNewEventHandler);
// Bind to the BindingSource (supported at design time)
this.customersDataGridView.DataSource = _bs;
}
private void BindingSource_AddingNewEventHandler(object sender, AddingNewEventArgs e)
{
// Set new item
e.NewObject = _service.CreateNewCustomer();
}
Supports type based binding (required for binding to factory based types)
The Windows Forms V1.0 and V1.0 designer required an instance of a type to exist at design time in order to setup design time data binding. The BindingSource provides type binding services such that it can “project” a type to bound controls as an empty list of that type. This enables both design time and runtime binding to factory based business objects:
public void Initialize()
{
// Design time setup
_bs = new BindingSource();
// Design time (or run-time binding to type)
// Controls bound to the BindingSource will act as if they are bound to an empty
// typed list of Customers
_dc.DataSource = typeof(Customer);
}
Provides centralized control for binding operations
A common binding request is the ability to suspend and resume binding for a data source. In V1 and V1.1 the CurrencyManager provided SuspendBinding() and ResumeBinding() methods but these only worked for Simple Binding. When binding through a BindingSource, you can suspend both simple and complex binding by having the BindingSource disable firing of ListChanged events (ListChanged events control binding). To do this, set the BindingSource “RaiseListChangedEvents” property to false.
Simplifies currency management
The BindingSource component exposes most of the CurrencyManager events and properties (see the Currency Management section for more information on CurrencyManagers). This enables design time event wire-up of common currency related events such as “CurrentChanged” and “PositionChanged”.
Simplifies binding to web services via indirection
In V1 and V1.1, when binding to objects such as a DataSet, customers bind directly to the object (as is expected):
// DataSet is a member variable (_ds)
Services.BooksService service = new Services.BookService();
_ds = service.GetBooksByAuthor(this.AuthorTextBox.Text);
// Bind Grid (show returned results)
this.authorsDataGridView.DataSource = _ds;
// Show details in simple controls
this.priceLabel.DataBindings.Add("Text", _ds, "Price");
this.publishDateLabel.DataBindings.Add("Text", _ds, "PublishDate");
this.ISBNLabel.DataBindings.Add("Text", _ds, "ISBN");
This works well for simple cases but can be problematic if the source object changes. As a first attempt, many users try to re-set the bound object (see below).
// First attempt, reset the DataSet
_ds = service.GetBooksByAuthor(this.AuthorTextBox.Text);
Given this doesn’t work, users move on re-setting all bindings:
public void AuthorSelected()
{
DataSet ds = service.GetBooksByAuthor(this.AuthorTextBox.Text);
// Reset All Bindings
ResetBindings(ds);
}
public void ResetBindings(DataSet ds)
{
// Bind Grid (show returned results)
this.authorsDataGridView.DataSource = ds;
// Show details in simple controls
this.priceLabel.DataBindings.Add("Text", ds, "Price");
this.publishDateLabel.DataBindings.Add("Text", ds, "PublishDate");
this.ISBNLabel.DataBindings.Add("Text", ds, "ISBN");
}
While this does work, it requires more work on the user’s part and cannot be setup at design time. For DataSets, users can short circuit this, but few customers discover this:
// First attempt, reset the DataSet
DataSet ds = service.GetBooksByAuthor(this.AuthorTextBox.Text);
_ds.Clear();
_ds.Merge(ds);
The BindingSource provides a level of indirection at both design-time and run-time that alleviates the need for users to reset their bindings or merge data sets.
private BindingSource _bs;
private void Initialize()
{
_bs = new BindingSource();
// Bind to the BindingSource (supported at design time)
this.authorsDataGridView.DataSource = _bs;
// Bind to the BindingSource (supported at design time)
this.priceLabel.DataBindings.Add("Text", _bs, "Price");
this.publishDateLabel.DataBindings.Add("Text", _bs, "PublishDate");
this.ISBNLabel.DataBindings.Add("Text", _bs, "ISBN");
}
public void AuthorSelected()
{
// Reset the BindingSource data source (resets bindings)
_dc.DataSource = service.GetBooksByAuthor(this.AuthorTextBox.Text);
}
Q. What is a BindingNavigator?
The BindingNavigator control represents a standardized way to navigate data on a form. When a BindingNavigator is connected to a BindingSource it can be used to navigate through the rows of the BindingSource’s (the rows of the BindingSources’ data source). By default, the BindingNavigator user interface is composed of a series of VCR-like buttons for common data-related actions, such as adding, deleting, and navigating data.
Q. What is BindingList<T>?
The fundamental two-way binding interface in the .NET Framework is IBindingList. The IBindingList interface is required for two way data binding and implemented by data access layers such as ADO.NET. In VS 2005, we have implemented a concrete, generic version of IBindingList called BindingList<T>. The goals of BindingList<T> are: · Make it easier for developers to implement IBindingLists (lists that have the same binding fidelity as ADO.NET). IBindingList is not trivial to implement due to the subtle interaction between IBindingList, IEditableObject and the CurrencyManager.
· Provide consistency with other generic lists provided in the Whidbey release of the framework (e.g. List<T>).
When a data source is a list, the data source needs to provide both list and property change notification via the IBindingList interface. List change notification is used to notify user interface elements when an item has been added, removed or deleted from the list. Property change notification on a list is used to notify user interface elements that a property on an item in the list has changed (e.g. the “Name” property on Customer instance in the nth position of the list changed). One key aspect of list binding in Windows Forms is that IBindingList provides both list based change notification and property based change notification. In other words, and this is a key point, Windows Forms controls that are bound to a list will not listen to property change notification provided by items within the list – rather Windows Forms requires the list to provide this notification on behalf of the contained items. One key advantage of using BindingList<T> is that it will automatically translate child INotifyPropertyChanged events into IBindingList.ListChanged events.
Q. What is INotifyPropertyChanged?
Business objects and controls do not have a generic way to provide notification when a property changes. The current convention is to provide a property changed event for each property (e.g. “PropertyName”Changed event handler). For business object types or controls with many properties, this can lead to a cumbersome object model. INotifyPropertyChanged provides a simpler, interface based approach to providing property change notification.
Sample: Simple Binding with INotifyPropertyChanged Change Notification (VS 2005) (VS Project: PropertyChangeNotification)
using System.ComponentModel;
public class CurrentTime : INotifyPropertyChanged
{
System.Windows.Forms.Timer _timer;
public CurrentTime()
{
/***************************************************************
* Use a timer to keep track of the current time
***************************************************************/
_timer = new System.Windows.Forms.Timer();
/***************************************************************
* Update the time every second
***************************************************************/
_timer.Interval = 1000;
_timer.Tick += delegate { this.Now = DateTime.Now; };
_timer.Start();
}
/*******************************************************************
* Use a timer to keep track of the current time
*******************************************************************/
private DateTime _now = DateTime.Now;
/*******************************************************************
* Property Change Notification fired – bound UI elements will
* update when this property changed
*
* This uses INotifyPropertyChanged
*******************************************************************/
public DateTime Now
{
get { return _now; }
private set
{
if (_now != value)
{
_now = value;
OnPropertyChanged(“Now”);
}
}
}
/*******************************************************************
* Provide the INotifyPropertyChanged.PropertyChanged event
*******************************************************************/
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName)
{
OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (null != PropertyChanged)
{
PropertyChanged(this, e);
}
}
}
14.40
Unknown
