[.NET 2.0+] Custom Typed Collections and Data-binding Support

[jmcilhinney]

For this example I used the project from the previous post as a starting point, modified it and I've attached the new version to this post. This new version addresses the issue I mentioned at the end of the previous post. Now, if you sort the grid, either by clicking a column header or the Sort button, and then you edit the data, the grid will resort itself automatically. How is this achieved? Read on.

The first step was to make the Person class implement the INotifyPropertyChanged interface:

Imports System.ComponentModel
 
Public Class Person
    Implements System.ComponentModel.INotifyPropertyChanged
 
    Private _id As Integer
    Private _firstName As String
    Private _lastName As String
 
 
    Public Property ID() As Integer
        Get
            Return Me._id
        End Get
        Set(ByVal value As Integer)
            If Me._id <> value Then
                Me._id = value
                Me.OnPropertyChanged(New PropertyChangedEventArgs("ID"))
            End If
        End Set
    End Property
 
    Public Property FirstName() As String
        Get
            Return Me._firstName
        End Get
        Set(ByVal value As String)
            If Me._firstName <> value Then
                Me._firstName = value
                Me.OnPropertyChanged(New PropertyChangedEventArgs("FirstName"))
            End If
        End Set
    End Property
 
    Public Property LastName() As String
        Get
            Return Me._lastName
        End Get
        Set(ByVal value As String)
            If Me._lastName <> value Then
                Me._lastName = value
                Me.OnPropertyChanged(New PropertyChangedEventArgs("LastName"))
            End If
        End Set
    End Property
 
 
    Public Sub New(ByVal id As Integer, _
                   ByVal firstName As String, _
                   ByVal lastName As String)
        Me.ID = id
        Me.FirstName = firstName
        Me.LastName = lastName
    End Sub
 
 
    ''' <summary>
    ''' Occurs when a property value changes.
    ''' </summary>
    Public Event PropertyChanged(ByVal sender As Object, _
                                 ByVal e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged
 
 
    ''' <summary>
    ''' Raises the PropertyChanged event.
    ''' </summary>
    Protected Overridable Sub OnPropertyChanged(ByVal e As PropertyChangedEventArgs)
        RaiseEvent PropertyChanged(Me, e)
    End Sub
 
End Class

Now a Person object will notify any listeners each time one of its property values changes. This has two effects:

1. If we edit a property value of a Person object in code, that change will be reflected automatically in any bound controls. That's because bound controls listen for the PropertyChanged event of the items they're bound to.

2. Our collection knows when a property value of an item changes so it can resort itself if necessary.

The second effect is what we're specifically interested in here. In order to implement this we must first add an event handler to the PersonCollection class to handle the PropertyChanged event of its items:

''' <summary>
''' Handles the PropertyChanged event for all items in the collection.
''' </summary>
''' <param name="sender">
''' The item whose property value has changed.
''' </param>
''' <param name="e">
''' Contains the name of the property whose value has changed.
''' </param>
Private Sub Person_PropertyChanged(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
    If Me._sortProperty.Name = e.PropertyName Then
        'A value has changed in the property by which the items are sorted so resort the collection.
        Me.ApplySortCore(Me._sortProperty, Me._sortDirection)
    End If
End Sub

Now, this method is supposed to handle the PropertyChanged event for all the items in the collection and none that aren't. This doesn't happen automatically. We need to attach the event handler as an item is added to the collection and, just as importantly, we need to detach the event handler as an item is removed from the collection:

''' <summary>
''' Removes all elements from the collection.
''' </summary>
Protected Overrides Sub ClearItems()
    'Detach event handlers from all items.
    For Each item As Person In Me.Items
        RemoveHandler item.PropertyChanged, AddressOf Person_PropertyChanged
    Next
 
    MyBase.ClearItems()
End Sub
 
''' <summary>
''' Inserts the specified item in the list at the specified index.
''' </summary>
Protected Overrides Sub InsertItem(ByVal index As Integer, ByVal item As Person)
    MyBase.InsertItem(index, item)
 
    'Attach event handlers to the item being added.
    AddHandler item.PropertyChanged, AddressOf Person_PropertyChanged
End Sub
 
''' <summary>
''' Removes the item at the specified index.
''' </summary>
Protected Overrides Sub RemoveItem(ByVal index As Integer)
    'Detach event handlers from the item being removed.
    RemoveHandler Me.Items(index).PropertyChanged, AddressOf Person_PropertyChanged
 
    MyBase.RemoveItem(index)
End Sub
 
''' <summary>
''' Replaces the item at the specified index with the specified item.
''' </summary>
Protected Overrides Sub SetItem(ByVal index As Integer, ByVal item As Person)
    'Detach event handlers from the item being removed.
    RemoveHandler Me.Items(index).PropertyChanged, AddressOf Person_PropertyChanged
 
    MyBase.SetItem(index, item)
 
    'Attach event handlers to the item being added.
    AddHandler item.PropertyChanged, AddressOf Person_PropertyChanged
End Sub

That looks after resorting when existing items are edited. We need only extend that slightly to resort the collection when new items are added:

''' <summary>
''' Inserts the specified item in the list at the specified index.
''' </summary>
Protected Overrides Sub InsertItem(ByVal index As Integer, ByVal item As Person)
    MyBase.InsertItem(index, item)
 
    'Attach event handlers to the item being added.
    AddHandler item.PropertyChanged, AddressOf Person_PropertyChanged
 
    If Me._sortProperty IsNot Nothing Then
        'Ensure that the collection maintains the correct sort order.
        Me.ApplySortCore(Me._sortProperty, Me._sortDirection)
    End If
End Sub
 
''' <summary>
''' Replaces the item at the specified index with the specified item.
''' </summary>
Protected Overrides Sub SetItem(ByVal index As Integer, ByVal item As Person)
    'Detach event handlers from the item being removed.
    RemoveHandler Me.Items(index).PropertyChanged, AddressOf Person_PropertyChanged
 
    MyBase.SetItem(index, item)
 
    'Attach event handlers to the item being added.
    AddHandler item.PropertyChanged, AddressOf Person_PropertyChanged
 
    If Me._sortProperty IsNot Nothing Then
        'Ensure that the collection maintains the correct sort order.
        Me.ApplySortCore(Me._sortProperty, Me._sortDirection)
    End If
End Sub

Now, if the collection is currently sorted, it is resorted each time a new item is added.

To test this out, try running the attached project and click a column header to sort the grid by that column. Now try editing a cell in that column such that it would make the rows out of order. Note that when you navigate away from that cell the grid resorts to maintain correct order in the sorted column. Now try entering new values in the controls at the bottom of the form and hitting the Add button. Make sure that adding the new item at the bottom of the grid would make the rows out of order. Note that the grid resorts itself such that the new item is placed to maintain correct order in the sorted column.

Again, I should point out that this code has not been implemented in the most efficient way possible. I've used the easiest way to provide sorting but the best way would require some more work. For instance, when an item is added, at the moment it is added to the end of the collection and the grid will update, then the collection is resorted and the grid will update again. In this example you don't see a difference and there are so few items that everything happens quickly enough that it doesn't matter. With a larger number of items it might become apparent that the grid was refreshing twice. Ideally we would avoid updating the grid twice by ensuring that the new item is inserted at the correct index to begin with. I'll look at optimising this code at a later time. Stay tuned!