Condividi tramite

IBindingList Interfaccia

  • Riferimento

Definizione

Spazio dei nomi:
System.ComponentModel
Assembly:
System.ComponentModel.TypeConverter.dll
Assembly:
System.dll
Assembly:
netstandard.dll

Fornisce le funzionalità necessarie per supportare scenari semplici e complessi quando si effettua un'associazione a un'origine dati.

public interface class IBindingList : System::Collections::IList
public interface IBindingList : System.Collections.IList
type IBindingList = interface
    interface ICollection
    interface IEnumerable
    interface IList
type IBindingList = interface
    interface IList
    interface ICollection
    interface IEnumerable
Public Interface IBindingList
Implements IList
Derivato
Implementazioni
ICollection IEnumerable IList

Esempio

Nell'esempio seguente viene fornita una semplice implementazione dell'interfaccia IBindingList . La CustomerList classe archivia le informazioni sui clienti in un elenco. In questo esempio si presuppone che sia stata usata la Customer classe che può essere trovata nell'esempio nella IEditableObject classe .

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
{

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

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

Commenti

Questa interfaccia viene implementata dalla DataView classe . L'implementazione di un metodo deve presentare lo stesso comportamento dell'implementazione di tale metodo nella DataView classe.

Quando si chiamano i ApplySort metodi o RemoveSort , è necessario generare un ListChanged evento con l'enumerazione Reset .

Quando si chiama il AddNew metodo, è necessario generare un ListChanged evento con l'enumerazione che contiene l'indice ItemAdded appropriato. La riga aggiunta si trova in uno stato in cui premere ESC su un DataGridView controllo può rimuovere la nuova riga. Generazione dell'evento ListChanged con l'enumerazione una seconda volta in questa riga indica che l'elemento ItemAdded è ora una riga non nello stato "nuovo".

Quando si rimuove un elemento o si chiama il CancelEdit metodo in una nuova riga (se tale riga implementa IEditableObject), è necessario generare un ListChanged evento con l'enumerazione che trasporta l'indice ItemDeleted appropriato.

Proprietà

AllowEdit

Indica se è possibile aggiornare gli elementi dell'elenco.
AllowNew

Indica se è possibile aggiungere elementi all'elenco utilizzando il metodo AddNew().
AllowRemove

Indica se è possibile rimuovere elementi dall'elenco utilizzando il metodo Remove(Object) o il metodo RemoveAt(Int32).
Count

Ottiene il numero di elementi contenuti in ICollection.

(Ereditato da ICollection)
IsFixedSize

Ottiene un valore che indica se IList ha dimensioni fisse.

(Ereditato da IList)
IsReadOnly

Ottiene un valore che indica se IList è di sola lettura.

(Ereditato da IList)
IsSorted

Indica se gli elementi dell'elenco sono ordinati.
IsSynchronized

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato (thread-safe).

(Ereditato da ICollection)
Item[Int32]

Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.

(Ereditato da IList)
SortDirection

Ottiene la direzione dell'ordinamento.
SortProperty

Ottiene l'oggetto PropertyDescriptor che viene utilizzato per l'ordinamento.
SupportsChangeNotification

Indica se viene generato un evento ListChanged quando viene modificato l'elenco o un elemento dell'elenco.
SupportsSearching

Indica se l'elenco supporta la ricerca con il metodo Find(PropertyDescriptor, Object).
SupportsSorting

Indica se l'elenco supporta l'ordinamento.
SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.

(Ereditato da ICollection)

Metodi

Add(Object)

Aggiunge un elemento a IList.

(Ereditato da IList)
AddIndex(PropertyDescriptor)

Consente di aggiungere l'oggetto PropertyDescriptor agli indici utilizzati per la ricerca.
AddNew()

Consente di aggiungere un nuovo elemento all'elenco.
ApplySort(PropertyDescriptor, ListSortDirection)

Ordina l'elenco in base a un oggetto PropertyDescriptor e a un oggetto ListSortDirection.
Clear()

Rimuove tutti gli elementi da IList.

(Ereditato da IList)
Contains(Object)

Stabilisce se IList contiene un valore specifico.

(Ereditato da IList)
CopyTo(Array, Int32)

Copia gli elementi di ICollection in Array a partire da un particolare indice Array.

(Ereditato da ICollection)
Find(PropertyDescriptor, Object)

Consente di restituire l'indice della riga che presenta il dato oggetto PropertyDescriptor.
GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.

(Ereditato da IEnumerable)
IndexOf(Object)

Determina l'indice di un elemento specifico in IList.

(Ereditato da IList)
Insert(Int32, Object)

Inserisce un elemento in IList in corrispondenza dell'indice specificato.

(Ereditato da IList)
Remove(Object)

Rimuove la prima occorrenza di un oggetto specifico da IList.

(Ereditato da IList)
RemoveAt(Int32)

Rimuove l'elemento IList in corrispondenza dell'indice specificato.

(Ereditato da IList)
RemoveIndex(PropertyDescriptor)

Consente di rimuovere l'oggetto PropertyDescriptor dagli indici utilizzati per la ricerca.
RemoveSort()

Consente di rimuovere qualsiasi ordinamento applicato utilizzando il metodo ApplySort(PropertyDescriptor, ListSortDirection).

Eventi

ListChanged

Si verifica quando viene modificato l'elenco o un elemento dell'elenco.

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)

Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a