IBindingList IBindingList IBindingList IBindingList Interface

정의

데이터 소스에 바인딩할 때 복잡하거나 간단한 시나리오 모두를 지원하는 데 필요한 기능을 제공합니다.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 발생 시켜야 메서드는 ListChanged 사용 하 여 이벤트를 Reset 열거형.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. 상태에서 추가 행이 위치 esc 키를 눌러는 DataGridView 컨트롤을 새 행을 제거할 수 있습니다.The added row is in a state where pressing the ESC on a DataGridView control can remove the new row. 발생 합니다 ListChanged 사용 하 여 이벤트를 ItemAdded 열거형이이 행에 두 번 항목은 이제 "new" 상태에 없는 행을 나타냅니다.Raising 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 AllowEdit AllowEdit AllowEdit

목록의 항목을 업데이트할 수 있는지 여부를 가져옵니다.Gets whether you can update items in the list.

AllowNew AllowNew AllowNew AllowNew

AddNew()를 사용하여 목록에 항목을 추가할 수 있는지 여부를 가져옵니다.Gets whether you can add items to the list using AddNew().

AllowRemove AllowRemove AllowRemove AllowRemove

Remove(Object) 또는 RemoveAt(Int32)를 사용하여 목록에서 항목을 제거할 수 있는지 여부를 가져옵니다.Gets whether you can remove items from the list, using Remove(Object) or RemoveAt(Int32).

Count Count Count Count

ICollection에 포함된 요소 수를 가져옵니다.Gets the number of elements contained in the ICollection.

(Inherited from ICollection)
IsFixedSize IsFixedSize IsFixedSize IsFixedSize

IList의 크기가 고정되어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the IList has a fixed size.

(Inherited from IList)
IsReadOnly IsReadOnly IsReadOnly IsReadOnly

IList가 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the IList is read-only.

(Inherited from IList)
IsSorted IsSorted IsSorted IsSorted

목록의 항목이 정렬되는지 여부를 가져옵니다.Gets whether the items in the list are sorted.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

ICollection에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지를 나타내는 값을 가져옵니다.Gets a value indicating whether access to the ICollection is synchronized (thread safe).

(Inherited from ICollection)
Item[Int32] Item[Int32] Item[Int32] Item[Int32]

지정한 인덱스에 있는 요소를 가져오거나 설정합니다.Gets or sets the element at the specified index.

(Inherited from IList)
SortDirection SortDirection SortDirection SortDirection

정렬 방향을 가져옵니다.Gets the direction of the sort.

SortProperty SortProperty SortProperty SortProperty

정렬에 사용되는 PropertyDescriptor를 가져옵니다.Gets the PropertyDescriptor that is being used for sorting.

SupportsChangeNotification SupportsChangeNotification SupportsChangeNotification SupportsChangeNotification

목록이 변경되거나 목록의 항목이 변경될 때 ListChanged 이벤트가 발생되는지 여부를 가져옵니다.Gets whether a ListChanged event is raised when the list changes or an item in the list changes.

SupportsSearching SupportsSearching SupportsSearching SupportsSearching

목록이 Find(PropertyDescriptor, Object) 메서드를 사용한 검색 기능을 지원하는지 여부를 가져옵니다.Gets whether the list supports searching using the Find(PropertyDescriptor, Object) method.

SupportsSorting SupportsSorting SupportsSorting SupportsSorting

목록이 정렬을 지원하는지 여부를 가져옵니다.Gets whether the list supports sorting.

SyncRoot SyncRoot SyncRoot SyncRoot

ICollection에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the ICollection.

(Inherited from ICollection)

메서드

Add(Object) Add(Object) Add(Object) Add(Object)

IList에 항목을 추가합니다.Adds an item to the IList.

(Inherited from IList)
AddIndex(PropertyDescriptor) AddIndex(PropertyDescriptor) AddIndex(PropertyDescriptor) AddIndex(PropertyDescriptor)

검색에 사용되는 인덱스에 PropertyDescriptor를 추가합니다.Adds the PropertyDescriptor to the indexes used for searching.

AddNew() AddNew() AddNew() AddNew()

목록에 새 항목을 추가합니다.Adds a new item to the list.

ApplySort(PropertyDescriptor, ListSortDirection) ApplySort(PropertyDescriptor, ListSortDirection) ApplySort(PropertyDescriptor, ListSortDirection) ApplySort(PropertyDescriptor, ListSortDirection)

PropertyDescriptorListSortDirection에 따라 목록을 정렬합니다.Sorts the list based on a PropertyDescriptor and a ListSortDirection.

Clear() Clear() Clear() Clear()

IList에서 항목을 모두 제거합니다.Removes all items from the IList.

(Inherited from IList)
Contains(Object) Contains(Object) Contains(Object) Contains(Object)

IList에 특정 값이 들어 있는지 여부를 확인합니다.Determines whether the IList contains a specific value.

(Inherited from IList)
CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

특정 ICollection 인덱스부터 시작하여 Array의 요소를 Array에 복사합니다.Copies the elements of the ICollection to an Array, starting at a particular Array index.

(Inherited from ICollection)
Find(PropertyDescriptor, Object) Find(PropertyDescriptor, Object) Find(PropertyDescriptor, Object) Find(PropertyDescriptor, Object)

지정된 PropertyDescriptor가 있는 행의 인덱스를 반환합니다.Returns the index of the row that has the given PropertyDescriptor.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

컬렉션을 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through a collection.

(Inherited from IEnumerable)
IndexOf(Object) IndexOf(Object) IndexOf(Object) IndexOf(Object)

IList에서 특정 항목의 인덱스를 결정합니다.Determines the index of a specific item in the IList.

(Inherited from IList)
Insert(Int32, Object) Insert(Int32, Object) Insert(Int32, Object) Insert(Int32, Object)

항목을 IList의 지정된 인덱스에 삽입합니다.Inserts an item to the IList at the specified index.

(Inherited from IList)
Remove(Object) Remove(Object) Remove(Object) Remove(Object)

IList에서 맨 처음 발견되는 특정 개체를 제거합니다.Removes the first occurrence of a specific object from the IList.

(Inherited from IList)
RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32)

지정한 인덱스에서 IList 항목을 제거합니다.Removes the IList item at the specified index.

(Inherited from IList)
RemoveIndex(PropertyDescriptor) RemoveIndex(PropertyDescriptor) RemoveIndex(PropertyDescriptor) RemoveIndex(PropertyDescriptor)

검색에 사용되는 인덱스에서 PropertyDescriptor를 제거합니다.Removes the PropertyDescriptor from the indexes used for searching.

RemoveSort() RemoveSort() RemoveSort() RemoveSort()

ApplySort(PropertyDescriptor, ListSortDirection)를 사용하여 적용되는 모든 정렬을 제거합니다.Removes any sort applied using ApplySort(PropertyDescriptor, ListSortDirection).

이벤트

ListChanged ListChanged ListChanged ListChanged

목록 또는 목록의 항목이 변경될 때 발생합니다.Occurs when the list changes or an item in the list changes.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

변환를 IEnumerableIQueryable합니다.Converts an IEnumerable to an IQueryable.

적용 대상