IBindingList Interfaz

Definición

Espacio de nombres:

System.ComponentModel

Ensamblado:

System.ComponentModel.TypeConverter.dll

Proporciona las características necesarias para admitir escenarios tanto complejos como simples en el momento de enlazar a un origen de datos.

C#

public interface IBindingList : System.Collections.IList

Derivado

System.ComponentModel.BindingList<T>

System.ComponentModel.IBindingListView

System.Data.DataView

System.Data.DataViewManager

System.Windows.Forms.BindingSource

Implementaciones

ICollection IEnumerable IList

Ejemplos

En el ejemplo siguiente se proporciona una implementación sencilla de la IBindingList interfaz . La CustomerList clase almacena la información del cliente en una lista. En este ejemplo se supone que ha usado la Customer clase que se puede encontrar en el ejemplo de la IEditableObject clase .

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

Comentarios

La clase implementa DataView esta interfaz. La implementación de un método debe mostrar el mismo comportamiento que la implementación de ese método en la DataView clase .

Al llamar a los ApplySort métodos o RemoveSort , debe generar un ListChanged evento con la Reset enumeración .

Al llamar al AddNew método , debe generar un ListChanged evento con la ItemAdded enumeración que lleva el índice adecuado. La fila agregada está en un estado en el que presionar ESC en un DataGridView control puede quitar la nueva fila. Generar el ListChanged evento con la ItemAdded enumeración una segunda vez en esta fila indica que el elemento ahora es una fila que no está en el estado "nuevo".

Al quitar un elemento o llamar al CancelEdit método en una nueva fila (si esa fila implementa IEditableObject), debe generar un ListChanged evento con la ItemDeleted enumeración que lleva el índice adecuado.

Propiedades

AllowEdit	Obtiene si se pueden actualizar los elementos de la lista.
AllowNew	Obtiene si se pueden agregar elementos a la lista mediante AddNew().
AllowRemove	Obtiene si se pueden quitar elementos de la lista mediante Remove(Object) o RemoveAt(Int32).
Count	Obtiene el número de elementos incluidos en ICollection. (Heredado de ICollection)
IsFixedSize	Obtiene un valor que indica si la interfaz IList tiene un tamaño fijo. (Heredado de IList)
IsReadOnly	Obtiene un valor que indica si IList es de solo lectura. (Heredado de IList)
IsSorted	Obtiene si están ordenados los elementos de la lista.
IsSynchronized	Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos). (Heredado de ICollection)
Item[Int32]	Obtiene o establece el elemento en el índice especificado. (Heredado de IList)
SortDirection	Obtiene la dirección de la ordenación.
SortProperty	Obtiene PropertyDescriptor que se utiliza para ordenar.
SupportsChangeNotification	Obtiene si se provoca un evento ListChanged cuando cambia la lista o un elemento de la lista.
SupportsSearching	Obtiene si la lista admite búsquedas mediante el método Find(PropertyDescriptor, Object).
SupportsSorting	Obtiene si la lista admite la ordenación.
SyncRoot	Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection. (Heredado de ICollection)

Métodos

Add(Object)	Agrega un elemento a IList. (Heredado de IList)
AddIndex(PropertyDescriptor)	Agrega PropertyDescriptor a los índices utilizados para las búsquedas.
AddNew()	Agrega un nuevo elemento a la lista.
ApplySort(PropertyDescriptor, ListSortDirection)	Ordena la lista basándose en PropertyDescriptor y ListSortDirection.
Clear()	Quita todos los elementos de IList. (Heredado de IList)
Contains(Object)	Determina si IList contiene un valor específico. (Heredado de IList)
CopyTo(Array, Int32)	Copia los elementos de ICollection en Array, empezando por un índice determinado de Array. (Heredado de ICollection)
Find(PropertyDescriptor, Object)	Devuelve el índice de la fila que tiene el PropertyDescriptor especificado.
GetEnumerator()	Devuelve un enumerador que recorre en iteración una colección. (Heredado de IEnumerable)
IndexOf(Object)	Determina el índice de un elemento específico de IList. (Heredado de IList)
Insert(Int32, Object)	Inserta un elemento en la interfaz IList, en el índice especificado. (Heredado de IList)
Remove(Object)	Quita la primera aparición de un objeto específico de la interfaz IList. (Heredado de IList)
RemoveAt(Int32)	Quita el elemento de la interfaz IList que se encuentra en el índice especificado. (Heredado de IList)
RemoveIndex(PropertyDescriptor)	Quita el PropertyDescriptor de los índices utilizados para las búsquedas.
RemoveSort()	Quita cualquier ordenación aplicada mediante el ApplySort(PropertyDescriptor, ListSortDirection).

Eventos

ListChanged

Se produce cuando cambia la lista o un elemento de la lista.

Métodos de extensión

Cast<TResult>(IEnumerable)	Convierte los elementos de IEnumerable en el tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de IEnumerable en función de un tipo especificado.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte una interfaz IEnumerable en IQueryable.

Se aplica a