IBindingList Schnittstelle

Definition

Namespace:

System.ComponentModel

Assembly:

System.dll

Stellt die Features bereit, die erforderlich sind, um komplexe und einfache Szenarien beim Binden an eine Datenquelle zu unterstützen.

public interface class IBindingList : System::Collections::IList

public interface IBindingList : System.Collections.IList

type IBindingList = interface
    interface IList
    interface ICollection
    interface IEnumerable

Public Interface IBindingList
Implements 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.

public ref class CustomersList: public CollectionBase, public IBindingList
{
private:
   ListChangedEventArgs^ resetEvent;
   ListChangedEventHandler^ onListChanged;
   virtual event ListChangedEventHandler^ ListChanged;

public:
   property bool AllowEdit 
   {
      // Implements IBindingList.
      virtual bool get() sealed
      {
         return true;
      }
   }

   virtual property bool AllowNew 
   {
      bool get()
      {
         return true;
      }
   }

   property bool AllowRemove 
   {
      virtual bool get()
      {
         return true;
      }

   }

   property bool SupportsChangeNotification 
   {
      virtual bool get()
      {
         return true;
      }

   }

   property bool SupportsSearching 
   {
      virtual bool get()
      {
         return true;
      }

   }

   property bool SupportsSorting 
   {
      virtual bool get()
      {
         return true;
      }

   }

   // Methods.
   virtual Object^ AddNew()
   {
      Customer^ c = gcnew Customer( this->Count->ToString() );
      List->Add( c );
      return c;
   }


   property bool IsSorted 
   {

      // Unsupported properties.
      virtual bool get()
      {
         throw gcnew NotSupportedException;
         return false;
      }

   }

   property ListSortDirection SortDirection 
   {
      virtual ListSortDirection get()
      {
         throw gcnew NotSupportedException;
         return ListSortDirection::Ascending;
      }

   }

   property PropertyDescriptor^ SortProperty 
   {
      virtual PropertyDescriptor^ get()
      {
         throw gcnew NotSupportedException;
         return nullptr;
      }

   }

   // Unsupported Methods.
   virtual void AddIndex( PropertyDescriptor^ property )
   {
      throw gcnew NotSupportedException;
   }

   virtual void ApplySort( PropertyDescriptor^ property, ListSortDirection direction )
   {
      throw gcnew NotSupportedException;
   }

   virtual int Find( PropertyDescriptor^ property, Object^ key )
   {
      throw gcnew NotSupportedException;
      return 0;
   }

   virtual void RemoveIndex( PropertyDescriptor^ property )
   {
      throw gcnew NotSupportedException;
   }

   virtual void RemoveSort()
   {
      throw gcnew NotSupportedException;
   }


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

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

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

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

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

   virtual void OnInsertComplete( int index, Object^ value ) override
   {
      Customer^ c = safe_cast<Customer^>(value);
      c->Parent = this;
      OnListChanged( gcnew ListChangedEventArgs( ListChangedType::ItemAdded,index ) );
   }

   virtual void OnRemoveComplete( int index, Object^ value ) override
   {
      Customer^ c = safe_cast<Customer^>(value);
      c->Parent = this;
      OnListChanged( gcnew ListChangedEventArgs( ListChangedType::ItemDeleted,index ) );
   }

   virtual void OnSetComplete( int index, Object^ oldValue, Object^ newValue ) override
   {
      if ( oldValue != newValue )
      {
         Customer^ oldcust = safe_cast<Customer^>(oldValue);
         Customer^ newcust = safe_cast<Customer^>(newValue);
         oldcust->Parent = 0;
         newcust->Parent = this;
         OnListChanged( gcnew ListChangedEventArgs( ListChangedType::ItemAdded,index ) );
      }
   }

public:

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

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

   property Object^ Item [int]
   {
      Object^ get( int index )
      {
         return static_cast<Customer^>(List->Item[ index ]);
      }

      void set( int index, Object^ value )
      {
         List->Item[ index ] = value;
      }

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

   Customer^ AddNew()
   {
      return safe_cast<Customer^>(static_cast<IBindingList^>(this)->AddNew());
   }

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

internal:

   // Called by Customer when it changes.
   void CustomerChanged( Customer^ cust )
   {
      int index = List->IndexOf( cust );
      OnListChanged( gcnew ListChangedEventArgs( ListChangedType::ItemChanged,index ) );
   }

};

public class CustomersList : CollectionBase, IBindingList
{
    readonly ListChangedEventArgs resetEvent = new(ListChangedType.Reset, -1);
    ListChangedEventHandler onListChanged;

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

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

    public int Add(Customer value) => List.Add(value);

    public Customer AddNew() => (Customer)((IBindingList)this).AddNew();

    public void Remove(Customer value) => List.Remove(value);

    protected virtual void OnListChanged(ListChangedEventArgs ev) => onListChanged?.Invoke(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 => true;

    bool IBindingList.AllowNew => true;

    bool IBindingList.AllowRemove => true;

    bool IBindingList.SupportsChangeNotification => true;

    bool IBindingList.SupportsSearching => false;

    bool IBindingList.SupportsSorting => false;

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

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

    // Unsupported properties.
    bool IBindingList.IsSorted => throw new NotSupportedException();

    ListSortDirection IBindingList.SortDirection => throw new NotSupportedException();

    PropertyDescriptor IBindingList.SortProperty => 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.
    static Customer ReadCustomer1() => new("536-45-1245")
    {
        FirstName = "Jo",
        LastName = "Brown"
    };

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

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 


    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 


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


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



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



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


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


    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 


    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 


    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 


    ' 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 


    ' 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 


    ' 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 


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


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


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


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


    ' 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 


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

Hinweise

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

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

Wenn Sie die AddNew Methode aufrufen, sollten Sie ein ListChanged Ereignis mit der Enumeration auslösen, die ItemAdded den entsprechenden Index enthält. Die hinzugefügte Zeile befindet sich in einem Zustand, in dem durch Drücken der ESC auf einem DataGridView Steuerelement die neue Zeile entfernt werden kann. Wenn Sie das ListChanged Ereignis mit der ItemAdded Enumeration ein zweites Mal in dieser Zeile auslösen, wird angegeben, dass das Element jetzt eine Zeile ist, die nicht im Zustand "neu" ist.

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

Eigenschaften

Name	Beschreibung
AllowEdit	Ruft ab, ob Elemente in der Liste aktualisiert werden können.
AllowNew	Ruft ab, ob Sie der Liste Mithilfe AddNew()von Elementen hinzufügen können.
AllowRemove	Ruft ab, ob Sie Elemente aus der Liste entfernen können, verwenden Remove(Object) oder RemoveAt(Int32).
Count	Ruft die Anzahl der Elemente ab, die in der ICollection. (Geerbt von ICollection)
IsFixedSize	Ruft einen Wert ab, der angibt, ob die IList Größe fest ist. (Geerbt von IList)
IsReadOnly	Ruft einen Wert ab, der angibt, ob dies IList schreibgeschützt ist. (Geerbt von IList)
IsSorted	Ruft ab, ob die Elemente in der Liste sortiert sind.
IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert wird (Threadsicher). (Geerbt von ICollection)
Item[Int32]	Ruft das Element am angegebenen Index ab oder legt es fest. (Geerbt von IList)
SortDirection	Ruft die Richtung der Sortierung ab.
SortProperty	Ruft ab, die für die PropertyDescriptor Sortierung verwendet wird.
SupportsChangeNotification	Ruft ab, ob ein ListChanged Ereignis ausgelöst wird, wenn sich die Liste ändert oder ein Element in der Liste geändert wird.
SupportsSearching	Ruft ab, ob die Liste die Suche mithilfe der Find(PropertyDescriptor, Object) Methode unterstützt.
SupportsSorting	Ruft ab, ob die Liste die Sortierung unterstützt.
SyncRoot	Ruft ein Objekt ab, das zum Synchronisieren des Zugriffs auf die ICollectionverwendet werden kann. (Geerbt von ICollection)

Methoden

Name	Beschreibung
Add(Object)	Fügt ein Element zum IList. (Geerbt von IList)
AddIndex(PropertyDescriptor)	Fügt die PropertyDescriptor Indizes hinzu, die für die Suche verwendet werden.
AddNew()	Fügt der Liste ein neues Element hinzu.
ApplySort(PropertyDescriptor, ListSortDirection)	Sortiert die Liste nach einem PropertyDescriptor und einem ListSortDirection.
Clear()	Entfernt alle Elemente aus dem IList. (Geerbt von IList)
Contains(Object)	Bestimmt, ob der IList Wert einen bestimmten Wert enthält. (Geerbt von IList)
CopyTo(Array, Int32)	Kopiert die Elemente des Elements in ICollection ein Array, beginnend bei einem bestimmten Array Index. (Geerbt von ICollection)
Find(PropertyDescriptor, Object)	Gibt den Index der Zeile zurück, die den angegebenen PropertyDescriptorWert aufweist.
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 ein Element an den IList angegebenen Index ein. (Geerbt von IList)
Remove(Object)	Entfernt das erste Vorkommen eines bestimmten Objekts aus dem IList. (Geerbt von IList)
RemoveAt(Int32)	Entfernt das IList Element am angegebenen Index. (Geerbt von IList)
RemoveIndex(PropertyDescriptor)	Entfernt die Indizes, die PropertyDescriptor für die Suche verwendet werden.
RemoveSort()	Entfernt jede Sortierung, die mit ApplySort(PropertyDescriptor, ListSortDirection)angewendet wird.

Ereignisse

Name	Beschreibung
ListChanged	Tritt auf, wenn sich die Liste ändert oder ein Element in der Liste geändert wird.

Erweiterungsmethoden

Name	Beschreibung
AsParallel(IEnumerable)	Aktiviert die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Wandelt eine IEnumerable in eine IQueryableum.
Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um.
OfType<TResult>(IEnumerable)	Filtert die Elemente einer IEnumerable basierend auf einem angegebenen Typ.