IBindingList Interfejs

Definicja

Przestrzeń nazw:

System.ComponentModel

Zestaw:

System.ComponentModel.TypeConverter.dll

Udostępnia funkcje wymagane do obsługi zarówno złożonych, jak i prostych scenariuszy podczas tworzenia powiązania ze źródłem danych.

C#

public interface IBindingList : System.Collections.IList

Pochodne

System.ComponentModel.BindingList<T>

System.ComponentModel.IBindingListView

System.Data.DataView

System.Data.DataViewManager

System.Windows.Forms.BindingSource

Implementuje

ICollection IEnumerable IList

Przykłady

W poniższym przykładzie przedstawiono prostą implementację interfejsu IBindingList . Klasa CustomerList przechowuje informacje o klientach na liście. W tym przykładzie przyjęto założenie, że użyto Customer klasy , która znajduje się w przykładzie IEditableObject w klasie .

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

Uwagi

Ten interfejs jest implementowany przez klasę DataView . Implementacja metody powinna mieć takie samo zachowanie jak implementacja tej metody w DataView klasie.

Podczas wywoływania ApplySort metod lub RemoveSort należy zgłosić ListChanged zdarzenie z wyliczeniem Reset .

Po wywołaniu AddNew metody należy zgłosić ListChanged zdarzenie z ItemAdded wyliczeniem, które nosi odpowiedni indeks. Dodany wiersz jest w stanie, w którym naciśnięcie klawisza ESC w kontrolce DataGridView może usunąć nowy wiersz. Podniesienie zdarzenia przy ListChangedItemAdded użyciu wyliczenia po raz drugi w tym wierszu oznacza, że element jest teraz wierszem, który nie znajduje się w stanie "nowy".

Po usunięciu elementu lub wywołaniu CancelEdit metody w nowym wierszu (jeśli ten wiersz implementuje IEditableObject), należy zgłosić ListChanged zdarzenie z ItemDeleted wyliczeniem przenoszącym odpowiedni indeks.

Właściwości

AllowEdit	Pobiera informacje o tym, czy można aktualizować elementy na liście.
AllowNew	Pobiera informacje o tym, czy można dodawać elementy do listy przy użyciu polecenia AddNew().
AllowRemove	Pobiera informacje o tym, czy można usunąć elementy z listy, przy użyciu polecenia Remove(Object) lub RemoveAt(Int32).
Count	Pobiera liczbę elementów zawartych w słowniku ICollection. (Odziedziczone po ICollection)
IsFixedSize	Pobiera wartość wskazującą, czy ma IList stały rozmiar. (Odziedziczone po IList)
IsReadOnly	Pobiera wartość wskazującą, czy kolekcja IList jest przeznaczona tylko do odczytu. (Odziedziczone po IList)
IsSorted	Pobiera informacje o tym, czy elementy na liście są sortowane.
IsSynchronized	Pobiera wartość wskazującą, czy dostęp do elementu ICollection jest synchronizowany (bezpieczny wątk). (Odziedziczone po ICollection)
Item[Int32]	Pobiera lub ustawia element pod określonym indeksem. (Odziedziczone po IList)
SortDirection	Pobiera kierunek sortowania.
SortProperty	Pobiera element PropertyDescriptor używany do sortowania.
SupportsChangeNotification	Pobiera informację o tym ListChanged , czy zdarzenie jest zgłaszane, gdy lista ulegnie zmianie, czy element na liście ulegnie zmianie.
SupportsSearching	Pobiera, czy lista obsługuje wyszukiwanie przy użyciu Find(PropertyDescriptor, Object) metody .
SupportsSorting	Określa, czy lista obsługuje sortowanie.
SyncRoot	Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu ICollection. (Odziedziczone po ICollection)

Metody

Add(Object)	Dodaje element do elementu IList. (Odziedziczone po IList)
AddIndex(PropertyDescriptor)	Dodaje element PropertyDescriptor do indeksów używanych do wyszukiwania.
AddNew()	Dodaje nowy element do listy.
ApplySort(PropertyDescriptor, ListSortDirection)	Sortuje listę na podstawie elementu PropertyDescriptor i ListSortDirection.
Clear()	Usuwa wszystkie elementy z elementu IList. (Odziedziczone po IList)
Contains(Object)	Określa, czy element IList zawiera określoną wartość. (Odziedziczone po IList)
CopyTo(Array, Int32)	Kopiuje elementy ICollection elementu do obiektu Array, zaczynając od określonego Array indeksu. (Odziedziczone po ICollection)
Find(PropertyDescriptor, Object)	Zwraca indeks wiersza o podanej PropertyDescriptorwartości .
GetEnumerator()	Zwraca moduł wyliczający, który iteruje po kolekcji. (Odziedziczone po IEnumerable)
IndexOf(Object)	Określa indeks określonego elementu w elemencie IList. (Odziedziczone po IList)
Insert(Int32, Object)	Wstawia element do IList obiektu w określonym indeksie. (Odziedziczone po IList)
Remove(Object)	Usuwa pierwsze wystąpienie określonego obiektu z obiektu IList. (Odziedziczone po IList)
RemoveAt(Int32)	Usuwa IList element w określonym indeksie. (Odziedziczone po IList)
RemoveIndex(PropertyDescriptor)	Usuwa element PropertyDescriptor z indeksów używanych do wyszukiwania.
RemoveSort()	Usuwa wszelkie zastosowane sortowanie przy użyciu polecenia ApplySort(PropertyDescriptor, ListSortDirection).

Zdarzenia

ListChanged

Występuje, gdy lista ulegnie zmianie lub zmieni się element na liście.

Metody rozszerzania

Cast<TResult>(IEnumerable)	Rzutuje elementy obiektu IEnumerable na określony typ.
OfType<TResult>(IEnumerable)	Filtruje elementy IEnumerable elementu na podstawie określonego typu.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje element IEnumerable na .IQueryable

Dotyczy