IBindingList インターフェイス

定義

データ ソースへの連結時の複雑な処理と単純な処理を両方ともサポートするために必要な機能を提供します。Provides the features required to support both complex and simple scenarios when binding to a data source.

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
派生
実装

次の例では、 IBindingListインターフェイスの単純な実装を示します。The following example provides a simple implementation of the IBindingList interface. クラスCustomerListは、顧客情報を一覧に格納します。The CustomerList class stores customer information in a list. この例では、 Customer IEditableObjectクラスの例にあるクラスを使用していることを前提としています。This example assumes that you have used the Customer class that can be found in the example in the IEditableObject class.

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

注釈

このインターフェイスは、 DataViewクラスによって実装されます。This interface is implemented by the DataView class. メソッドの実装では、 DataViewクラスのメソッドの実装と同じ動作を行う必要があります。Implementation of a method should exhibit the same behavior as the implementation of that method in the DataView class.

メソッドApplySortまたはRemoveSortメソッドを呼び出す場合は、 Reset列挙ListChanged体を使用してイベントを発生させる必要があります。When you call the ApplySort or RemoveSort methods, you should raise a ListChanged event with the Reset enumeration.

AddNewメソッドを呼び出す場合は、適切なインデックスListChangedを持つItemAdded列挙体を使用してイベントを発生させる必要があります。When you call the AddNew method, you should raise a ListChanged event with the ItemAdded enumeration carrying the appropriate index. 追加された行は、 DataGridViewコントロールの ESC キーを押すと新しい行が削除される状態にあります。The added row is in a state where pressing the ESC on a DataGridView control can remove the new row. この行の2回ItemAdded目の列挙を使用してイベントを発生させると、その項目が"new"状態ではない行になります。ListChangedRaising the ListChanged event with the ItemAdded enumeration a second time on this row indicates that the item is now a row not in the "new" state.

項目を削除したり、新しい行CancelEditに対してメソッドを呼び出したりすると ( IEditableObjectその行がを実装しListChangedている場合ItemDeleted )、適切なインデックスを持つ列挙体を使用してイベントを発生させる必要があります。When you remove an item or call the CancelEdit method on a new row (if that row implements IEditableObject), you should raise a ListChanged event with the ItemDeleted enumeration carrying the appropriate index.

プロパティ

AllowEdit

リストの項目を更新できるかどうかを示す値を取得します。Gets whether you can update items in the list.

AllowNew

AddNew() を使用してリストに項目を追加できるかどうかを示す値を取得します。Gets whether you can add items to the list using AddNew().

AllowRemove

Remove(Object) または RemoveAt(Int32) を使用してリストから項目を削除できるかどうかを示す値を取得します。Gets whether you can remove items from the list, using Remove(Object) or RemoveAt(Int32).

Count

ICollection に格納されている要素の数を取得します。Gets the number of elements contained in the ICollection.

(継承元 ICollection)
IsFixedSize

IList が固定サイズかどうかを示す値を取得します。Gets a value indicating whether the IList has a fixed size.

(継承元 IList)
IsReadOnly

IList が読み取り専用かどうかを示す値を取得します。Gets a value indicating whether the IList is read-only.

(継承元 IList)
IsSorted

リストの項目が並べ替え済みかどうかを示す値を取得します。Gets whether the items in the list are sorted.

IsSynchronized

ICollection へのアクセスが同期されている (スレッド セーフである) かどうかを示す値を取得します。Gets a value indicating whether access to the ICollection is synchronized (thread safe).

(継承元 ICollection)
Item[Int32]

指定したインデックスにある要素を取得または設定します。Gets or sets the element at the specified index.

(継承元 IList)
SortDirection

並べ替えの順序を取得します。Gets the direction of the sort.

SortProperty

並べ替えに使用されている PropertyDescriptor を取得します。Gets the PropertyDescriptor that is being used for sorting.

SupportsChangeNotification

リストまたはリスト内の項目が変更されたときに、ListChanged イベントを発生させるかどうかを示す値を取得します。Gets whether a ListChanged event is raised when the list changes or an item in the list changes.

SupportsSearching

リストが Find(PropertyDescriptor, Object) メソッドを使用した検索をサポートしているかどうかを示す値を取得します。Gets whether the list supports searching using the Find(PropertyDescriptor, Object) method.

SupportsSorting

リストが並べ替えをサポートしているかどうかを示す値を取得します。Gets whether the list supports sorting.

SyncRoot

ICollection へのアクセスを同期するために使用できるオブジェクトを取得します。Gets an object that can be used to synchronize access to the ICollection.

(継承元 ICollection)

メソッド

Add(Object)

IList に項目を追加します。Adds an item to the IList.

(継承元 IList)
AddIndex(PropertyDescriptor)

検索に使用されるインデックスに PropertyDescriptor を追加します。Adds the PropertyDescriptor to the indexes used for searching.

AddNew()

リストに新しい項目を追加します。Adds a new item to the list.

ApplySort(PropertyDescriptor, ListSortDirection)

PropertyDescriptorListSortDirection に基づいて並べ替えを行います。Sorts the list based on a PropertyDescriptor and a ListSortDirection.

Clear()

IList からすべての項目を削除します。Removes all items from the IList.

(継承元 IList)
Contains(Object)

IList に特定の値が格納されているかどうかを判断します。Determines whether the IList contains a specific value.

(継承元 IList)
CopyTo(Array, Int32)

ICollection の要素を Array にコピーします。Array の特定のインデックスからコピーが開始されます。Copies the elements of the ICollection to an Array, starting at a particular Array index.

(継承元 ICollection)
Find(PropertyDescriptor, Object)

指定された PropertyDescriptor を保持する行のインデックスを返します。Returns the index of the row that has the given PropertyDescriptor.

GetEnumerator()

コレクションを反復処理する列挙子を返します。Returns an enumerator that iterates through a collection.

(継承元 IEnumerable)
IndexOf(Object)

IList 内の特定の項目のインデックスを確認します。Determines the index of a specific item in the IList.

(継承元 IList)
Insert(Int32, Object)

指定したインデックスの IList に項目を挿入します。Inserts an item to the IList at the specified index.

(継承元 IList)
Remove(Object)

特定のオブジェクトが IList 内にあるときに、最初に出現したものを削除します。Removes the first occurrence of a specific object from the IList.

(継承元 IList)
RemoveAt(Int32)

指定したインデックスにある IList 項目を削除します。Removes the IList item at the specified index.

(継承元 IList)
RemoveIndex(PropertyDescriptor)

検索に使用されるインデックスから PropertyDescriptor を削除します。Removes the PropertyDescriptor from the indexes used for searching.

RemoveSort()

ApplySort(PropertyDescriptor, ListSortDirection) を使用して並べ替えを適用した場合は、その並べ替えを削除します。Removes any sort applied using ApplySort(PropertyDescriptor, ListSortDirection).

イベント

ListChanged

リストまたはリスト内の項目が変更された場合に発生します。Occurs when the list changes or an item in the list changes.

拡張メソッド

Cast<TResult>(IEnumerable)

IEnumerable の要素を、指定した型にキャストします。Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

指定された型に基づいて IEnumerable の要素をフィルター処理します。Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

クエリの並列化を有効にします。Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable に変換します。Converts an IEnumerable to an IQueryable.

適用対象