IBindingList Schnittstelle

Definition

Namespace:

System.ComponentModel

Assembly:

System.ComponentModel.TypeConverter.dll

Stellt die Features bereit, die für die Unterstützung komplexer wie auch einfacher Szenarien mit Bindung an eine Datenquelle erforderlich sind.

C#

public interface IBindingList : System.Collections.IList

Abgeleitet

System.ComponentModel.BindingList<T>

System.ComponentModel.IBindingListView

System.Data.DataView

System.Data.DataViewManager

System.Windows.Forms.BindingSource

Implementiert

ICollection IEnumerable IList

Beispiele

Im folgenden Beispiel wird eine einfache Implementierung der IBindingList -Schnittstelle bereitgestellt. Die CustomerList -Klasse speichert Kundeninformationen in einer Liste. In diesem Beispiel wird davon ausgegangen, dass Sie die Customer -Klasse verwendet haben, die im Beispiel in der IEditableObject -Klasse zu finden ist.

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

Hinweise

Diese Schnittstelle wird von der DataView -Klasse implementiert. Die Implementierung einer Methode sollte das gleiche Verhalten aufweisen wie die Implementierung dieser Methode in der DataView -Klasse.

Wenn Sie die ApplySort -Methode oder RemoveSort aufrufen, sollten Sie ein ListChanged -Ereignis mit der Reset -Enumeration auslösen.

Wenn Sie die AddNew -Methode aufrufen, sollten Sie ein ListChanged Ereignis auslösen, bei dem die ItemAdded Enumeration den entsprechenden Index enthält. Die hinzugefügte Zeile befindet sich in einem Zustand, in dem das Drücken des ESC für ein DataGridView Steuerelement die neue Zeile entfernen kann. Das Auslösen des Ereignisses ListChanged mit der ItemAdded -Enumeration ein zweites Mal in dieser Zeile bedeutet, dass das Element jetzt eine Zeile ist, die sich nicht im Zustand "neu" befindet.

Wenn Sie ein Element entfernen oder die CancelEdit -Methode für eine neue Zeile aufrufen (wenn diese Zeile implementiert IEditableObject), sollten Sie ein ListChanged Ereignis mit der Enumeration auslösen, die ItemDeleted den entsprechenden Index enthält.

Eigenschaften

AllowEdit	Ruft ab, ob Elemente der Liste aktualisiert werden können.
AllowNew	Ruft ab, ob der Liste mithilfe von AddNew() Elemente hinzugefügt werden können.
AllowRemove	Ruft ab, ob Elemente unter Verwendung von Remove(Object) oder RemoveAt(Int32) aus der Liste entfernt werden können.
Count	Ruft die Anzahl der Elemente ab, die in ICollection enthalten sind. (Geerbt von ICollection)
IsFixedSize	Ruft einen Wert ab, der angibt, ob das IList eine feste Größe aufweist. (Geerbt von IList)
IsReadOnly	Ruft einen Wert ab, der angibt, ob das IList schreibgeschützt ist. (Geerbt von IList)
IsSorted	Ruft ab, ob die Element in der Liste sortiert werden.
IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert (threadsicher) ist. (Geerbt von ICollection)
Item[Int32]	Ruft das Element am angegebenen Index ab oder legt dieses fest. (Geerbt von IList)
SortDirection	Ruft die Sortierrichtung ab.
SortProperty	Ruft den PropertyDescriptor ab, der für die Sortierung verwendet wird.
SupportsChangeNotification	Ruft ab, ob bei Änderungen der Liste oder eines Elements ein ListChanged-Ereignis ausgelöst wird.
SupportsSearching	Ruft ab, ob die Liste die Suche mit der Find(PropertyDescriptor, Object)-Methode unterstützt.
SupportsSorting	Ruft ab, ob die Liste die Sortierung unterstützt.
SyncRoot	Ruft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann. (Geerbt von ICollection)

Methoden

Add(Object)	Fügt der IList ein Element hinzu. (Geerbt von IList)
AddIndex(PropertyDescriptor)	Fügt den Indizes, die für die Suche verwendet werden, den PropertyDescriptor hinzu.
AddNew()	Fügt der Liste ein neues Element hinzu.
ApplySort(PropertyDescriptor, ListSortDirection)	Sortiert die Liste entsprechend einem PropertyDescriptor und einer ListSortDirection.
Clear()	Entfernt alle Elemente aus IList. (Geerbt von IList)
Contains(Object)	Ermittelt, ob die IList einen bestimmten Wert enthält. (Geerbt von IList)
CopyTo(Array, Int32)	Kopiert die Elemente der ICollection in ein Array, beginnend bei einem bestimmten Array-Index. (Geerbt von ICollection)
Find(PropertyDescriptor, Object)	Gibt den Index der Zeile mit dem angegebenen PropertyDescriptor zurück.
GetEnumerator()	Gibt einen Enumerator zurück, der eine Auflistung durchläuft. (Geerbt von IEnumerable)
IndexOf(Object)	Bestimmt den Index eines bestimmten Elements in der IList. (Geerbt von IList)
Insert(Int32, Object)	Fügt am angegebenen Index ein Element in die IList ein. (Geerbt von IList)
Remove(Object)	Entfernt das erste Vorkommen eines angegebenen Objekts aus der IList. (Geerbt von IList)
RemoveAt(Int32)	Entfernt das IList-Element am angegebenen Index. (Geerbt von IList)
RemoveIndex(PropertyDescriptor)	Entfernt den PropertyDescriptor aus den Indizes, die für die Suche verwendet werden.
RemoveSort()	Entfernt alle Sortierungen, die unter Verwendung von ApplySort(PropertyDescriptor, ListSortDirection) angewendet wurden.

Ereignisse

ListChanged

Tritt ein, wenn die Liste oder ein Element der Liste geändert wird.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Gilt für: