IBindingList Interface

Définition

Espace de noms:

System.ComponentModel

Assembly:

System.ComponentModel.TypeConverter.dll

Fournit les fonctionnalités nécessaires à la prise en charge de scénarios complexes et simples lors de la liaison à une source de données.

C#

public interface IBindingList : System.Collections.IList

Dérivé

System.ComponentModel.BindingList<T>

System.ComponentModel.IBindingListView

System.Data.DataView

System.Data.DataViewManager

System.Windows.Forms.BindingSource

Implémente

ICollection IEnumerable IList

Exemples

L’exemple suivant fournit une implémentation simple de l’interface IBindingList . La CustomerList classe stocke les informations client dans une liste. Cet exemple suppose que vous avez utilisé la Customer classe qui se trouve dans l’exemple dans la IEditableObject classe .

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

Remarques

Cette interface est implémentée par la DataView classe . L’implémentation d’une méthode doit présenter le même comportement que l’implémentation de cette méthode dans la DataView classe .

Lorsque vous appelez les ApplySort méthodes ou RemoveSort , vous devez déclencher un ListChanged événement avec l’énumération Reset .

Lorsque vous appelez la AddNew méthode , vous devez déclencher un ListChanged événement avec l’énumération ItemAdded contenant l’index approprié. La ligne ajoutée est dans un état où le fait d’appuyer sur échap sur un DataGridView contrôle peut supprimer la nouvelle ligne. Le déclenchement de l’événement ListChanged avec l’énumération ItemAdded une deuxième fois sur cette ligne indique que l’élément est maintenant une ligne qui n’est pas à l’état « nouveau ».

Lorsque vous supprimez un élément ou appelez la CancelEdit méthode sur une nouvelle ligne (si cette ligne implémente IEditableObject), vous devez déclencher un ListChanged événement avec l’énumération ItemDeleted contenant l’index approprié.

Propriétés

AllowEdit	Obtient une valeur indiquant si vous pouvez mettre à jour des éléments de la liste.
AllowNew	Obtient une valeur indiquant si vous pouvez ajouter des éléments à la liste à l'aide de AddNew().
AllowRemove	Obtient une valeur indiquant si vous pouvez supprimer des éléments de la liste à l'aide de Remove(Object) ou de RemoveAt(Int32).
Count	Obtient le nombre d’éléments contenus dans le ICollection. (Hérité de ICollection)
IsFixedSize	Obtient une valeur indiquant si IList est de taille fixe. (Hérité de IList)
IsReadOnly	Obtient une valeur indiquant si IList est en lecture seule. (Hérité de IList)
IsSorted	Obtient une valeur indiquant si les éléments de la liste sont triés.
IsSynchronized	Obtient une valeur indiquant si l’accès à ICollection est synchronisé (thread-safe). (Hérité de ICollection)
Item[Int32]	Obtient ou définit l'élément au niveau de l'index spécifié. (Hérité de IList)
SortDirection	Obtient le sens du tri.
SortProperty	Obtient le PropertyDescriptor utilisé actuellement pour le tri.
SupportsChangeNotification	Obtient une valeur indiquant si l'événement ListChanged est déclenché en cas de modification de la liste ou d'un de ses éléments.
SupportsSearching	Obtient une valeur indiquant si la liste prend en charge la recherche à l'aide de la méthode Find(PropertyDescriptor, Object).
SupportsSorting	Obtient une valeur indiquant si la liste prend en charge le tri.
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à ICollection. (Hérité de ICollection)

Méthodes

Add(Object)	Ajoute un élément à IList. (Hérité de IList)
AddIndex(PropertyDescriptor)	Ajoute PropertyDescriptor aux index utilisés pour la recherche.
AddNew()	Ajoute un nouvel élément à la liste.
ApplySort(PropertyDescriptor, ListSortDirection)	Trie la liste en fonction d'un PropertyDescriptor et d'un ListSortDirection.
Clear()	Supprime tous les éléments de IList. (Hérité de IList)
Contains(Object)	Détermine si IList contient une valeur spécifique. (Hérité de IList)
CopyTo(Array, Int32)	Copie les éléments de ICollection dans Array, à partir d'un index particulier de Array. (Hérité de ICollection)
Find(PropertyDescriptor, Object)	Retourne l'index de la ligne possédant le PropertyDescriptor donné.
GetEnumerator()	Retourne un énumérateur qui itère au sein d’une collection. (Hérité de IEnumerable)
IndexOf(Object)	Détermine l'index d'un élément spécifique d'IList. (Hérité de IList)
Insert(Int32, Object)	Insère un élément dans IList à l’index spécifié. (Hérité de IList)
Remove(Object)	Supprime la première occurrence d’un objet spécifique de IList. (Hérité de IList)
RemoveAt(Int32)	Supprime l'élément IList au niveau de l'index spécifié. (Hérité de IList)
RemoveIndex(PropertyDescriptor)	Supprime PropertyDescriptor des index utilisés pour la recherche.
RemoveSort()	Supprime tout tri appliqué à l'aide de ApplySort(PropertyDescriptor, ListSortDirection).

Événements

ListChanged

Se produit en cas de modification de la liste ou d'un de ses éléments.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

S’applique à