IBindingList インターフェイス

定義

名前空間:: System.ComponentModel

アセンブリ:: System.dll

アセンブリ:: netstandard.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

データソースにバインドするときに複雑なシナリオと単純なシナリオの両方をサポートするために必要な機能を提供します。

public interface class IBindingList : System::Collections::IList

public interface IBindingList : System.Collections.IList

type IBindingList = interface
    interface IList
    interface ICollection
    interface IEnumerable

type IBindingList = interface
    interface ICollection
    interface IEnumerable
    interface IList

Public Interface IBindingList
Implements IList

派生: System.ComponentModel.BindingList<T>

System.ComponentModel.IBindingListView

System.Data.DataView

System.Data.DataViewManager

System.Windows.Forms.BindingSource

実装: ICollection IEnumerable IList

例

次の例では、 IBindingList インターフェイスの簡単な実装を示します。 CustomerList クラスは、顧客情報をリストに格納します。この例では、IEditableObject クラスの例にあるCustomer クラスを使用していることを前提としています。

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
{
    readonly ListChangedEventArgs resetEvent = new(ListChangedType.Reset, -1);
    ListChangedEventHandler onListChanged;

    public void LoadCustomers()
    {
        IList l = this;
        _ = l.Add(ReadCustomer1());
        _ = l.Add(ReadCustomer2());
        OnListChanged(resetEvent);
    }

    public Customer this[int index]
    {
        get => (Customer)List[index]; set => List[index] = value;
    }

    public int Add(Customer value) => List.Add(value);

    public Customer AddNew() => (Customer)((IBindingList)this).AddNew();

    public void Remove(Customer value) => List.Remove(value);

    protected virtual void OnListChanged(ListChangedEventArgs ev) => onListChanged?.Invoke(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 => true;

    bool IBindingList.AllowNew => true;

    bool IBindingList.AllowRemove => true;

    bool IBindingList.SupportsChangeNotification => true;

    bool IBindingList.SupportsSearching => false;

    bool IBindingList.SupportsSorting => false;

    // Events.
    public event ListChangedEventHandler ListChanged
    {
        add => onListChanged += value; remove => onListChanged -= value;
    }

    // Methods.
    object IBindingList.AddNew()
    {
        Customer c = new(Count.ToString());
        _ = List.Add(c);
        return c;
    }

    // Unsupported properties.
    bool IBindingList.IsSorted => throw new NotSupportedException();

    ListSortDirection IBindingList.SortDirection => throw new NotSupportedException();

    PropertyDescriptor IBindingList.SortProperty => 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.
    static Customer ReadCustomer1() => new("536-45-1245")
    {
        FirstName = "Jo",
        LastName = "Brown"
    };

    static Customer ReadCustomer2()
    {
        Customer cust = new("246-12-5645")
        {
            FirstName = "Robert",
            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 クラスによって実装されます。メソッドの実装は、 DataView クラスでのそのメソッドの実装と同じ動作を示す必要があります。

ApplySortメソッドまたはRemoveSort メソッドを呼び出す場合は、Reset列挙型を使用してListChanged イベントを発生させる必要があります。

AddNew メソッドを呼び出すときは、適切なインデックスを持つItemAdded列挙体でListChanged イベントを発生させる必要があります。追加された行は、 DataGridView コントロールの ESC キーを押すと新しい行を削除できる状態です。この行で ItemAdded 列挙で ListChanged イベントを 2 回目に発生させる場合は、アイテムが "新しい" 状態ではない行になったことを示します。

項目を削除するか、新しい行で CancelEdit メソッドを呼び出すとき (その行がIEditableObjectを実装している場合)、適切なインデックスを持つItemDeleted列挙体でListChangedイベントを発生させる必要があります。

プロパティ

名前	説明
AllowEdit	リスト内の項目を更新できるかどうかを取得します。
AllowNew	AddNew()を使用してリストに項目を追加できるかどうかを取得します。
AllowRemove	Remove(Object)またはRemoveAt(Int32)を使用して、リストから項目を削除できるかどうかを取得します。
Count	ICollectionに含まれる要素の数を取得します。 (継承元 ICollection)
IsFixedSize	IListに固定サイズがあるかどうかを示す値を取得します。 (継承元 IList)
IsReadOnly	IListが読み取り専用かどうかを示す値を取得します。 (継承元 IList)
IsSorted	リスト内の項目を並べ替えるかどうかを取得します。
IsSynchronized	ICollectionへのアクセスが同期されているかどうかを示す値を取得します (スレッドセーフ)。 (継承元 ICollection)
Item[Int32]	指定したインデックス位置にある要素を取得または設定します。 (継承元 IList)
SortDirection	並べ替えの方向を取得します。
SortProperty	並べ替えに使用されている PropertyDescriptor を取得します。
SupportsChangeNotification	リストが変更されたとき、またはリスト内の項目が変更されたときに、 ListChanged イベントが発生するかどうかを取得します。
SupportsSearching	Find(PropertyDescriptor, Object) メソッドを使用した検索がリストでサポートされているかどうかを取得します。
SupportsSorting	リストが並べ替えをサポートしているかどうかを取得します。
SyncRoot	ICollectionへのアクセスを同期するために使用できるオブジェクトを取得します。 (継承元 ICollection)

メソッド

名前	説明
Add(Object)	IListに項目を追加します。 (継承元 IList)
AddIndex(PropertyDescriptor)	検索に使用するインデックスに PropertyDescriptor を追加します。
AddNew()	リストに新しい項目を追加します。
ApplySort(PropertyDescriptor, ListSortDirection)	PropertyDescriptorとListSortDirectionに基づいてリストを並べ替えます。
Clear()	IListからすべての項目を削除します。 (継承元 IList)
Contains(Object)	IListに特定の値が含まれているかどうかを判断します。 (継承元 IList)
CopyTo(Array, Int32)	特定のICollectionインデックスから始まるArrayの要素をArrayにコピーします。 (継承元 ICollection)
Find(PropertyDescriptor, Object)	指定した PropertyDescriptorを持つ行のインデックスを返します。
GetEnumerator()	コレクションを反復処理する列挙子を返します。 (継承元 IEnumerable)
IndexOf(Object)	IList内の特定の項目のインデックスを決定します。 (継承元 IList)
Insert(Int32, Object)	指定したインデックス位置にある IList に項目を挿入します。 (継承元 IList)
Remove(Object)	特定のオブジェクトの最初の出現箇所を IListから削除します。 (継承元 IList)
RemoveAt(Int32)	指定したインデックス位置にある IList 項目を削除します。 (継承元 IList)
RemoveIndex(PropertyDescriptor)	検索に使用するインデックスから PropertyDescriptor を削除します。
RemoveSort()	ApplySort(PropertyDescriptor, ListSortDirection)を使用して適用された並べ替えを削除します。

イベント

名前	説明
ListChanged	リストが変更されたとき、またはリスト内の項目が変更されたときに発生します。

拡張メソッド

名前	説明
AsParallel(IEnumerable)	クエリの並列化を有効にします。
AsQueryable(IEnumerable)	IEnumerable を IQueryableに変換します。
Cast<TResult>(IEnumerable)	IEnumerable の要素を指定した型にキャストします。
OfType<TResult>(IEnumerable)	指定した型に基づいて、IEnumerable の要素をフィルター処理します。

適用対象

フィードバック

このページはお役に立ちましたか?