The INotifyPropertyChanged interface is used to notify
listeners that a property on the object has changed. When a property’s value
changes, you will fire the PropertyChanged event; I do this in the example
below in the NotifyPropertyChanged() method.
Your data binding may seem to work fine without implementing
this interface, but that is because the data in your object is probably only
changing when the user types in a new value to a control. What happens when
something in the business object changes for some another reason?
For example, in the code sample below when a property
changes, we are going to update the value in the LastUpdate property.
public class Person: INotifyPropertyChanged
private string _firstName;
private string _lastName;
private string _email;
private DateTime _lastUpdate;
public string FirstName
if (_firstName == value)
_firstName = value;
public string LastName
if (_lastName == value)
_lastName = value;
public string Email
if (_email == value)
_email = value;
public DateTime LastUpdate
public event PropertyChangedEventHandler PropertyChanged;
protected void NotifyPropertyChanged(string propertyName)
if (propertyName != "LastUpdate")
_lastUpdate = DateTime.Now;
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
Because we implemented INotifyPropertyChanged, a grid that
is bound to this object will get the updated value of LastUpdate when one of
the other properties changes.
The IDataErrorInfo interface provides a way for your business
object to provide error information to listeners, such as a grid or an
The IDataErrorInfo interface has two properties — an Error
property that returns an error message for the entire object and an indexer
that returns an error message for a specific property.
I am not exactly sure why Microsoft chose to use an indexer
in this interface. When you see code that says, “MessageBox.Show(person[”Email”]),”
you would not naturally think that you would be displaying an error message for
the Email property. In my opinion, something like GetError("Email")
would have been more fitting.
But all opinions aside, your best choice is probably to
implement this interface explicitly. By doing this, you will have to cast the
object to an IDataErrorInfo before you can access the indexer.
Person person = new Person();
// If you implement IDataErrorInfo explicitly, this will not compile
// If you implement IDataErrorInfo explicitly, you have to cast
// the Person object to IDataErrorInfo in order to access the
// indexer. This allows you to have an indexer on your object
// for some other reason.
When you bind a control such as a grid to a list, you should
bind to a collection that implements IBindingList.
The IBindingList interface contains methods and properties that deal with
sorting of the list and the adding and deleting of items from the list. You can
use the System.ComponentModel.BindingList class in most cases, so you do not
necessarily have to know about all of the nitty gritty details of implementing
IBindingList. The important thing to know is that a grid that is bound to an
IBindingList will automatically update when items are added or removed from the
When you want to add a new row to a data bound grid, you
will have to do so in the underlying list by calling IBindingList methods.
// This line will throw an exception because you cannot
// call this method when the grid is data bound -- you
// have to add the item to the underlying list.
// This is the correct way.
Person newPerson = _list.AddNew();
If you want to remove an item from the list or the grid, you
can do it either by removing the object from the list or by telling the grid to
remove the row.
// Either one of the methods below will work for
// removing the row from the list and the grid.
if (/* remove from the underlying list */)
// Remove the item from the underlying list.
// Tell the grid to remove the row
interface provides functionality to commit or rollback changes to an object
that is used as a data source. The primary application of this is when you are
editing a record in a grid and you want to click a Cancel button and undo all
of the edits that you made to that record.
Implementing IEditableObject is fairly straightforward.
There are three methods: BeginEdit(), CancelEdit(), and EndEdit(). In
BeginEdit(), flag the object as being in edit mode and store off all of the
values in the object. In CancelEdit(), clear the edit mode flag and restore all
of the object values that you stored in BeginEdit(). In EndEdit(), clear the
edit mode flag, forget all of the values that you stored in BeginEdit() and, if
necessary, commit the changes to the object to your data store.
Here is the tricky part. If your object is bound to a grid,
for example, the grid will call BeginEdit() anytime you edit any part of the
record. So in your BeginEdit() method, you will want to keep track of whether
the object is already in edit mode so that you do not go storing off values
every time a cell is edited.
public void BeginEdit()
_originalValues = new Dictionary < string, object > ();
foreach (PropertyInfo pi in GetType().GetProperties())
_originalValues[pi.Name] = pi.GetValue(this, null);
_doingEdit = true;
If you are editing a record in a grid, for example, and you
select a different row, the grid will call EndEdit() for you. You can also call
EndEdit() and CancelEdit() yourself (for example, when a Save or Cancel button
The BindingSource component — tying it all together
In .NET 2.0 the BindingSource
component was introduced. The BindingSource acts as a layer of abstraction
between your control and your actual data source. In the designer you can set
the DataSource property of the BindingSource to an object type, which will
provide access to type information in the designer so that you can set up
almost all of your data binding in the designer.
Now if you select your BindingSource component as your
grid’s DataSource, all of the columns will be added to the grid and you will be
able to work with the columns at design-time.
Another benefit of the BindingSource component is that it
will allow you to choose from a list of your object’s properties when you want
to bind individual controls.
Not only that, but if your form contains an ErrorProvider
component on your form, you can set the DataSource of the ErrorProvider to the
BindingSource. And if you have implemented IDataErrorInfo on your business
object, the ErrorProvider will automatically display error messages in your