IBindingList Interface

Definition

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

C#
public interface IBindingList : System.Collections.IList
Derived
Implements

Examples

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.

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;
    }
}

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 DataGridView 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.

Properties

AllowEdit

Gets whether you can update items in the list.

AllowNew

Gets whether you can add items to the list using AddNew().

AllowRemove

Gets whether you can remove items from the list, using Remove(Object) or RemoveAt(Int32).

Count

Gets the number of elements contained in the ICollection.

(Inherited from ICollection)
IsFixedSize

Gets a value indicating whether the IList has a fixed size.

(Inherited from IList)
IsReadOnly

Gets a value indicating whether the IList is read-only.

(Inherited from IList)
IsSorted

Gets whether the items in the list are sorted.

IsSynchronized

Gets a value indicating whether access to the ICollection is synchronized (thread safe).

(Inherited from ICollection)
Item[Int32]

Gets or sets the element at the specified index.

(Inherited from IList)
SortDirection

Gets the direction of the sort.

SortProperty

Gets the PropertyDescriptor that is being used for sorting.

SupportsChangeNotification

Gets whether a ListChanged event is raised when the list changes or an item in the list changes.

SupportsSearching

Gets whether the list supports searching using the Find(PropertyDescriptor, Object) method.

SupportsSorting

Gets whether the list supports sorting.

SyncRoot

Gets an object that can be used to synchronize access to the ICollection.

(Inherited from ICollection)

Methods

Add(Object)

Adds an item to the IList.

(Inherited from IList)
AddIndex(PropertyDescriptor)

Adds the PropertyDescriptor to the indexes used for searching.

AddNew()

Adds a new item to the list.

ApplySort(PropertyDescriptor, ListSortDirection)

Sorts the list based on a PropertyDescriptor and a ListSortDirection.

Clear()

Removes all items from the IList.

(Inherited from IList)
Contains(Object)

Determines whether the IList contains a specific value.

(Inherited from IList)
CopyTo(Array, Int32)

Copies the elements of the ICollection to an Array, starting at a particular Array index.

(Inherited from ICollection)
Find(PropertyDescriptor, Object)

Returns the index of the row that has the given PropertyDescriptor.

GetEnumerator()

Returns an enumerator that iterates through a collection.

(Inherited from IEnumerable)
IndexOf(Object)

Determines the index of a specific item in the IList.

(Inherited from IList)
Insert(Int32, Object)

Inserts an item to the IList at the specified index.

(Inherited from IList)
Remove(Object)

Removes the first occurrence of a specific object from the IList.

(Inherited from IList)
RemoveAt(Int32)

Removes the IList item at the specified index.

(Inherited from IList)
RemoveIndex(PropertyDescriptor)

Removes the PropertyDescriptor from the indexes used for searching.

RemoveSort()

Removes any sort applied using ApplySort(PropertyDescriptor, ListSortDirection).

Events

ListChanged

Occurs when the list changes or an item in the list changes.

Extension Methods

Cast<TResult>(IEnumerable)

Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Enables parallelization of a query.

AsQueryable(IEnumerable)

Converts an IEnumerable to an IQueryable.

Applies to

Product Versions
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1