Provides the features required to support both complex and simple scenarios when binding to a data source.

For a list of all members of this type, see IBindingList Members.

[Visual Basic]
Public Interface IBindingList
   Inherits IList, ICollection, IEnumerable
[C#]
public interface IBindingList : IList, ICollection, IEnumerable
[C++]
public __gc __interface IBindingList : public IList, ICollection,
   IEnumerable
[JScript]
public interface IBindingList implements IList, ICollection,
   IEnumerable

Classes that Implement IBindingList

Remarks

This interface is implemented by the DataView class. Implementation of a method should exhibit the same behavior as the implementation of that method in the DataView class.

When you call the ApplySort or RemoveSort methods, you should raise a ListChanged event with the Reset enumeration.

When you call the AddNew method, you should raise a ListChanged event with the ItemAdded enumeration carrying the appropriate index. The added row is in a state where pressing the ESC on a DataGrid control can remove the new row. Raising the ListChanged event with the ItemAdded enumeration a second time on this row indicates that the item is now a row not in the "new" state.

When you remove an item or call the CancelEdit method on a new row (if that row implements IEditableObject), you should raise a ListChanged event with the ItemDeleted enumeration carrying the appropriate index.

Example

[Visual Basic, C#, C++] The following example provides a simple implementation of the IBindingList interface. The CustomerList class stores customer information in a list. This example assumes that you have used the Customer class that can be found in the example in the IEditableObject class.

[Visual Basic] 
Public Class CustomersList
    Inherits CollectionBase
    Implements IBindingList 

    Private resetEvent As New ListChangedEventArgs(ListChangedType.Reset, -1)
    Private onListChanged1 As ListChangedEventHandler


    Public Sub LoadCustomers()
        Dim l As IList = CType(Me, IList)
        l.Add(ReadCustomer1())
        l.Add(ReadCustomer2())
        OnListChanged(resetEvent)
    End Sub 'LoadCustomers


    Default Public Property Item(ByVal index As Integer) As Customer
        Get
            Return CType(List(index), Customer)
        End Get
        Set(ByVal Value As Customer)
            List(index) = Value
        End Set
    End Property


    Public Function Add(ByVal value As Customer) As Integer
        Return List.Add(value)
    End Function 'Add


    Public Function AddNew2() As Customer
        Return CType(CType(Me, IBindingList).AddNew(), Customer)
    End Function 'AddNew


    Public Sub Remove(ByVal value As Customer)
        List.Remove(value)
    End Sub 'Remove



    Protected Overridable Sub OnListChanged(ByVal ev As ListChangedEventArgs)
        If Not (onListChanged1 Is Nothing) Then
            onListChanged1(Me, ev)
        End If
    End Sub 'OnListChanged



    Protected Overrides Sub OnClear()
        Dim c As Customer
        For Each c In List
            c.parent = Nothing
        Next c
    End Sub 'OnClear


    Protected Overrides Sub OnClearComplete()
        OnListChanged(resetEvent)
    End Sub 'OnClearComplete


    Protected Overrides Sub OnInsertComplete(ByVal index As Integer, ByVal value As Object)
        Dim c As Customer = CType(value, Customer)
        c.parent = Me
        OnListChanged(New ListChangedEventArgs(ListChangedType.ItemAdded, index))
    End Sub 'OnInsertComplete


    Protected Overrides Sub OnRemoveComplete(ByVal index As Integer, ByVal value As Object)
        Dim c As Customer = CType(value, Customer)
        c.parent = Me
        OnListChanged(New ListChangedEventArgs(ListChangedType.ItemDeleted, index))
    End Sub 'OnRemoveComplete


    Protected Overrides Sub OnSetComplete(ByVal index As Integer, ByVal oldValue As Object, ByVal newValue As Object)
        If oldValue <> newValue Then

            Dim oldcust As Customer = CType(oldValue, Customer)
            Dim newcust As Customer = CType(newValue, Customer)

            oldcust.parent = Nothing
            newcust.parent = Me

            OnListChanged(New ListChangedEventArgs(ListChangedType.ItemAdded, index))
        End If
    End Sub 'OnSetComplete


    ' Called by Customer when it changes.
    Friend Sub CustomerChanged(ByVal cust As Customer)
        Dim index As Integer = List.IndexOf(cust)
        OnListChanged(New ListChangedEventArgs(ListChangedType.ItemChanged, index))
    End Sub 'CustomerChanged


    ' Implements IBindingList.

    ReadOnly Property AllowEdit() As Boolean Implements IBindingList.AllowEdit
        Get
            Return True
        End Get
    End Property

    ReadOnly Property AllowNew() As Boolean Implements IBindingList.AllowNew
        Get
            Return True
        End Get
    End Property

    ReadOnly Property AllowRemove() As Boolean Implements IBindingList.AllowRemove
        Get
            Return True
        End Get
    End Property

    ReadOnly Property SupportsChangeNotification() As Boolean Implements IBindingList.SupportsChangeNotification
        Get
            Return True
        End Get
    End Property

    ReadOnly Property SupportsSearching() As Boolean Implements IBindingList.SupportsSearching
        Get
            Return False
        End Get
    End Property

    ReadOnly Property SupportsSorting() As Boolean Implements IBindingList.SupportsSorting
        Get
            Return False
        End Get
    End Property

    ' Events.
    Public Event ListChanged As ListChangedEventHandler Implements IBindingList.ListChanged


    ' Methods.
    Function AddNew() As Object Implements IBindingList.AddNew
        Dim c As New Customer(Me.Count.ToString())
        List.Add(c)
        Return c
    End Function 'IBindingList.AddNew


    ' Unsupported properties.

    ReadOnly Property IsSorted() As Boolean Implements IBindingList.IsSorted
        Get
            Throw New NotSupportedException()
        End Get
    End Property

    ReadOnly Property SortDirection() As ListSortDirection Implements IBindingList.SortDirection
        Get
            Throw New NotSupportedException()
        End Get
    End Property


    ReadOnly Property SortProperty() As PropertyDescriptor Implements IBindingList.SortProperty
        Get
            Throw New NotSupportedException()
        End Get
    End Property


    ' Unsupported Methods.
    Sub AddIndex(ByVal prop As PropertyDescriptor) Implements IBindingList.AddIndex
        Throw New NotSupportedException()
    End Sub 'IBindingList.AddIndex


    Sub ApplySort(ByVal prop As PropertyDescriptor, ByVal direction As ListSortDirection) Implements IBindingList.ApplySort
        Throw New NotSupportedException()
    End Sub 'IBindingList.ApplySort


    Function Find(ByVal prop As PropertyDescriptor, ByVal key As Object) As Integer Implements IBindingList.Find
        Throw New NotSupportedException()
    End Function 'IBindingList.Find


    Sub RemoveIndex(ByVal prop As PropertyDescriptor) Implements IBindingList.RemoveIndex
        Throw New NotSupportedException()
    End Sub 'IBindingList.RemoveIndex


    Sub RemoveSort() Implements IBindingList.RemoveSort
        Throw New NotSupportedException()
    End Sub 'IBindingList.RemoveSort


    ' Worker functions to populate the list with data.
    Private Shared Function ReadCustomer1() As Customer
        Dim cust As New Customer("536-45-1245")
        cust.FirstName = "Jo"
        cust.LastName = "Brown"
        Return cust
    End Function 'ReadCustomer1


    Private Shared Function ReadCustomer2() As Customer
        Dim cust As New Customer("246-12-5645")
        cust.FirstName = "Robert"
        cust.LastName = "Brown"
        Return cust
    End Function 'ReadCustomer2
End Class 'CustomersList 


[C#] 
public class CustomersList :  CollectionBase, IBindingList
{

    private ListChangedEventArgs resetEvent = new ListChangedEventArgs(ListChangedType.Reset, -1);
    private ListChangedEventHandler onListChanged;

    public void LoadCustomers() 
    {
        IList l = (IList)this;
        l.Add(ReadCustomer1());
        l.Add(ReadCustomer2());
        OnListChanged(resetEvent);
    }

    public Customer this[int index] 
    {
        get 
        {
            return (Customer)(List[index]);
        }
        set 
        {
            List[index] = value;
        }
    }

    public int Add (Customer value) 
    {
        return List.Add(value);
    }

    public Customer AddNew() 
    {
        return (Customer)((IBindingList)this).AddNew();
    }

    public void Remove (Customer value) 
    {
        List.Remove(value);
    }

    
    protected virtual void OnListChanged(ListChangedEventArgs ev) 
    {
        if (onListChanged != null) 
        {
            onListChanged(this, ev);
        }
    }
    

    protected override void OnClear() 
    {
        foreach (Customer c in List) 
        {
            c.Parent = null;
        }
    }

    protected override void OnClearComplete() 
    {
        OnListChanged(resetEvent);
    }

    protected override void OnInsertComplete(int index, object value) 
    {
        Customer c = (Customer)value;
        c.Parent = this;
        OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
    }

    protected override void OnRemoveComplete(int index, object value) 
    {
        Customer c = (Customer)value;
        c.Parent = this;
        OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
    }

    protected override void OnSetComplete(int index, object oldValue, object newValue) 
    {
        if (oldValue != newValue) 
        {

            Customer oldcust = (Customer)oldValue;
            Customer newcust = (Customer)newValue;
            
            oldcust.Parent = null;
            newcust.Parent = this;
            
            
            OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
        }
    }
    
    // Called by Customer when it changes.
    internal void CustomerChanged(Customer cust) 
    {
        
        int index = List.IndexOf(cust);
        
        OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
    }
    

    // Implements IBindingList.
    bool IBindingList.AllowEdit 
    { 
        get { return true ; }
    }

    bool IBindingList.AllowNew 
    { 
        get { return true ; }
    }

    bool IBindingList.AllowRemove 
    { 
        get { return true ; }
    }

    bool IBindingList.SupportsChangeNotification 
    { 
        get { return true ; }
    }
    
    bool IBindingList.SupportsSearching 
    { 
        get { return false ; }
    }

    bool IBindingList.SupportsSorting 
    { 
        get { return false ; }
    }


    // Events.
    public event ListChangedEventHandler ListChanged 
    {
        add 
        {
            onListChanged += value;
        }
        remove 
        {
            onListChanged -= value;
        }
    }

    // Methods.
    object IBindingList.AddNew() 
    {
        Customer c = new Customer(this.Count.ToString());
        List.Add(c);
        return c;
    }


    // Unsupported properties.
    bool IBindingList.IsSorted 
    { 
        get { throw new NotSupportedException(); }
    }

    ListSortDirection IBindingList.SortDirection 
    { 
        get { throw new NotSupportedException(); }
    }


    PropertyDescriptor IBindingList.SortProperty 
    { 
        get { throw new NotSupportedException(); }
    }


    // Unsupported Methods.
    void IBindingList.AddIndex(PropertyDescriptor property) 
    {
        throw new NotSupportedException(); 
    }

    void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction) 
    {
        throw new NotSupportedException(); 
    }

    int IBindingList.Find(PropertyDescriptor property, object key) 
    {
        throw new NotSupportedException(); 
    }

    void IBindingList.RemoveIndex(PropertyDescriptor property) 
    {
        throw new NotSupportedException(); 
    }

    void IBindingList.RemoveSort() 
    {
        throw new NotSupportedException(); 
    }

    // Worker functions to populate the list with data.
    private static Customer ReadCustomer1() 
    {
        Customer cust = new Customer("536-45-1245");
        cust.FirstName = "Jo";
        cust.LastName = "Brown";
        return cust;
    }
    
    private static Customer ReadCustomer2() 
    {
        Customer cust = new Customer("246-12-5645");
        cust.FirstName = "Robert";
        cust.LastName = "Brown";
        return cust;
    }
    
    

[C++] 
public __gc class CustomersList : public CollectionBase, public IBindingList {
private:

    ListChangedEventArgs* resetEvent;
    ListChangedEventHandler* onListChanged;

    __event ListChangedEventHandler* ListChanged;


    // Implements IBindingList.
    __property bool IBindingList::get_AllowEdit()
    {
        return true;
    }

    __property bool IBindingList::get_AllowNew()
    {
        return true;
    }

    __property bool IBindingList::get_AllowRemove()
    {
        return true;
    }

    __property bool IBindingList::get_SupportsChangeNotification()
    {
        return true;
    }

    __property bool IBindingList::get_SupportsSearching()
    {
        return true;
    }

    __property bool IBindingList::get_SupportsSorting()
    {
        return true;
    }

    // Methods.
    Object* IBindingList::AddNew()
    {
        Customer* c = new Customer(__box(this->Count)->ToString());
        List->Add(c);
        return c;
    }

    // Unsupported properties.
    __property bool IBindingList::get_IsSorted()
    {
        throw new NotSupportedException();
        return false;
    }

    __property ListSortDirection IBindingList::get_SortDirection()
    {
        throw new NotSupportedException();
        return ListSortDirection::Ascending;
    }


    __property PropertyDescriptor* IBindingList::get_SortProperty()
    {
        throw new NotSupportedException();
        return 0;
    }


    // Unsupported Methods.
    void IBindingList::AddIndex(PropertyDescriptor* property)
    {
        throw new NotSupportedException();
    }

    void IBindingList::ApplySort(PropertyDescriptor* property, ListSortDirection direction)
    {
        throw new NotSupportedException();
    }

    int IBindingList::Find(PropertyDescriptor* property, Object* key)
    {
        throw new NotSupportedException();
        return 0;
    }

    void IBindingList::RemoveIndex(PropertyDescriptor* property)
    {
        throw new NotSupportedException();
    }

    void IBindingList::RemoveSort()
    {
        throw new NotSupportedException();
    }

    // Worker functions to populate the list with data.
    static Customer* ReadCustomer1()
    {
        Customer* cust = new Customer(S"536-45-1245");
        cust->FirstName = S"Jo";
        cust->LastName = S"Brown";
        return cust;
    }

    static Customer* ReadCustomer2()
    {
        Customer* cust = new Customer(S"246-12-5645");
        cust->FirstName = S"Robert";
        cust->LastName = S"Brown";
        return cust;
    }


protected:

    virtual void OnListChanged(ListChangedEventArgs* ev)
    {
        if (onListChanged != 0)
        {
            onListChanged(this, ev);
        }
    }

    void OnClear()
    {
        List->Clear();
    }

    void OnClearComplete()
    {
        OnListChanged(resetEvent);
    }

    void OnInsertComplete(int index, Object* value)
    {
        Customer* c = __try_cast<Customer*>(value);
        c->Parent = this;
        OnListChanged(new ListChangedEventArgs(ListChangedType::ItemAdded, index));
    }

    void OnRemoveComplete(int index, Object* value)
    {
        Customer* c = __try_cast<Customer*>(value);
        c->Parent = this;
        OnListChanged(new ListChangedEventArgs(ListChangedType::ItemDeleted, index));
    }

    void OnSetComplete(int index, Object* oldValue, Object* newValue)
    {
        if (oldValue != newValue)
        {

            Customer* oldcust = __try_cast<Customer*>(oldValue);
            Customer* newcust = __try_cast<Customer*>(newValue);

            oldcust->Parent = 0;
            newcust->Parent = this;


            OnListChanged(new ListChangedEventArgs(ListChangedType::ItemAdded, index));
        }
    }


public:

    // Constructor
    CustomersList() {
        resetEvent = new ListChangedEventArgs(ListChangedType::Reset, -1);
    }

    void LoadCustomers()
    {
        IList* l = static_cast<IList*>(this);
        l->Add(ReadCustomer1());
        l->Add(ReadCustomer2());
        OnListChanged(resetEvent);
    }

    __property Customer* get_Item(int index)
    {
        return static_cast<Customer*>(List->Item[index]);
    }

    __property void set_Item(int index, Customer* value)
    {
        List->Item[index] = value;
    }

    int Add (Customer* value)
    {
        return List->Add(value);
    }

    Customer* AddNew()
    {
        return __try_cast<Customer*>(static_cast<IBindingList*>(this)->AddNew());
    }

    void Remove (Customer* value)
    {
        List->Remove(value);
    }

private public:

    // Called by Customer when it changes.
    void CustomerChanged(Customer* cust)
    {
        int index = List->IndexOf(cust);

        OnListChanged(new ListChangedEventArgs(ListChangedType::ItemChanged, index));
    }

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

Requirements

Namespace: System.ComponentModel

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework - Windows CE .NET

Assembly: System (in System.dll)

See Also

IBindingList Members | System.ComponentModel Namespace