ICollection<T> Interfejs

Odwołanie

Definicja

Przestrzeń nazw:: System.Collections.Generic

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Definiuje metody manipulowania kolekcjami ogólnymi.

generic <typename T>
public interface class ICollection : System::Collections::Generic::IEnumerable<T>

public interface ICollection<T> : System.Collections.Generic.IEnumerable<T>

type ICollection<'T> = interface
    interface seq<'T>
    interface IEnumerable

Public Interface ICollection(Of T)
Implements IEnumerable(Of T)

Parametry typu

T

Typ elementów w kolekcji.

Pochodne: Microsoft.Extensions.DependencyInjection.IServiceCollection

Microsoft.Extensions.DependencyInjection.ServiceCollection

Microsoft.Extensions.Primitives.StringValues

System.Activities.Hosting.SymbolResolver

System.Activities.Presentation.Model.ModelItemCollection

Więcej…

Implementuje: IEnumerable<T> IEnumerable

Przykłady

Poniższy przykład implementuje interfejs w ICollection<T> celu utworzenia kolekcji obiektów niestandardowych Box o nazwie BoxCollection. Każda z nich Box ma właściwości wysokości, długości i szerokości, które służą do definiowania równości. Równość można zdefiniować jako wszystkie wymiary, które są takie same lub wolumin jest taki sam. Klasa Box implementuje IEquatable<T> interfejs, aby zdefiniować domyślną równość co wymiary, które są takie same.

Klasa BoxCollection implementuje metodę Contains , aby użyć domyślnej równości w celu określenia, czy element Box znajduje się w kolekcji. Ta metoda jest używana przez metodę Add , aby każdy Box dodany do kolekcji miał unikatowy zestaw wymiarów. Klasa BoxCollection udostępnia również przeciążenie Contains metody, która przyjmuje określony EqualityComparer<T> obiekt, taki jak BoxSameDimensions i BoxSameVol klasy w przykładzie.

W tym przykładzie zaimplementowany jest IEnumerator<T> również interfejs klasy BoxCollection , aby można było wyliczyć kolekcję.

using System;
using System.Collections;
using System.Collections.Generic;

class Program
{

    static void Main(string[] args)
    {

        BoxCollection bxList = new BoxCollection();

        bxList.Add(new Box(10, 4, 6));
        bxList.Add(new Box(4, 6, 10));
        bxList.Add(new Box(6, 10, 4));
        bxList.Add(new Box(12, 8, 10));

        // Same dimensions. Cannot be added:
        bxList.Add(new Box(10, 4, 6));

        // Test the Remove method.
        Display(bxList);
        Console.WriteLine("Removing 6x10x4");
        bxList.Remove(new Box(6, 10, 4));
        Display(bxList);

        // Test the Contains method.
        Box BoxCheck = new Box(8, 12, 10);
        Console.WriteLine("Contains {0}x{1}x{2} by dimensions: {3}",
            BoxCheck.Height.ToString(), BoxCheck.Length.ToString(),
            BoxCheck.Width.ToString(), bxList.Contains(BoxCheck).ToString());

        // Test the Contains method overload with a specified equality comparer.
        Console.WriteLine("Contains {0}x{1}x{2} by volume: {3}",
            BoxCheck.Height.ToString(), BoxCheck.Length.ToString(),
            BoxCheck.Width.ToString(), bxList.Contains(BoxCheck,
            new BoxSameVol()).ToString());
    }
    public static void Display(BoxCollection bxList)
    {
        Console.WriteLine("\nHeight\tLength\tWidth\tHash Code");
        foreach (Box bx in bxList)
        {
            Console.WriteLine("{0}\t{1}\t{2}\t{3}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString(), bx.GetHashCode().ToString());
        }

        // Results by manipulating the enumerator directly:

        //IEnumerator enumerator = bxList.GetEnumerator();
        //Console.WriteLine("\nHeight\tLength\tWidth\tHash Code");
        //while (enumerator.MoveNext())
        //{
        //    Box b = (Box)enumerator.Current;
        //    Console.WriteLine("{0}\t{1}\t{2}\t{3}",
        //    b.Height.ToString(), b.Length.ToString(),
        //    b.Width.ToString(), b.GetHashCode().ToString());
        //}

        Console.WriteLine();
    }

}

public class Box : IEquatable<Box>
{

    public Box(int h, int l, int w)
    {
        this.Height = h;
        this.Length = l;
        this.Width = w;
    }
    public int Height { get; set; }
    public int Length { get; set; }
    public int Width { get; set; }

    // Defines equality using the
    // BoxSameDimensions equality comparer.
    public bool Equals(Box other)
    {
        if (new BoxSameDimensions().Equals(this, other))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override bool Equals(object obj)
    {
        return base.Equals(obj);
    }

    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}

public class BoxCollection : ICollection<Box>
{
    // The generic enumerator obtained from IEnumerator<Box>
    // by GetEnumerator can also be used with the non-generic IEnumerator.
    // To avoid a naming conflict, the non-generic IEnumerable method
    // is explicitly implemented.

    public IEnumerator<Box> GetEnumerator()
    {
        return new BoxEnumerator(this);
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return new BoxEnumerator(this);
    }

    // The inner collection to store objects.
    private List<Box> innerCol;

    public BoxCollection()
    {
        innerCol = new List<Box>();
    }

    // Adds an index to the collection.
    public Box this[int index]
    {
        get { return (Box)innerCol[index]; }
        set { innerCol[index] = value; }
    }

    // Determines if an item is in the collection
    // by using the BoxSameDimensions equality comparer.
    public bool Contains(Box item)
    {
        bool found = false;

        foreach (Box bx in innerCol)
        {
            // Equality defined by the Box
            // class's implmentation of IEquatable<T>.
            if (bx.Equals(item))
            {
                found = true;
            }
        }

        return found;
    }

    // Determines if an item is in the
    // collection by using a specified equality comparer.
    public bool Contains(Box item, EqualityComparer<Box> comp)
    {
        bool found = false;

        foreach (Box bx in innerCol)
        {
            if (comp.Equals(bx, item))
            {
                found = true;
            }
        }

        return found;
    }

    // Adds an item if it is not already in the collection
    // as determined by calling the Contains method.
    public void Add(Box item)
    {

        if (!Contains(item))
        {
            innerCol.Add(item);
        }
        else
        {
            Console.WriteLine("A box with {0}x{1}x{2} dimensions was already added to the collection.",
                item.Height.ToString(), item.Length.ToString(), item.Width.ToString());
        }
    }

    public void Clear()
    {
        innerCol.Clear();
    }

    public void CopyTo(Box[] array, int arrayIndex)
    {
        if (array == null)
           throw new ArgumentNullException("The array cannot be null.");
        if (arrayIndex < 0)
           throw new ArgumentOutOfRangeException("The starting array index cannot be negative.");
        if (Count > array.Length - arrayIndex)
           throw new ArgumentException("The destination array has fewer elements than the collection.");

        for (int i = 0; i < innerCol.Count; i++) {
            array[i + arrayIndex] = innerCol[i];
        }
    }

    public int Count
    {
        get
        {
            return innerCol.Count;
        }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(Box item)
    {
        bool result = false;

        // Iterate the inner collection to
        // find the box to be removed.
        for (int i = 0; i < innerCol.Count; i++)
        {

            Box curBox = (Box)innerCol[i];

            if (new BoxSameDimensions().Equals(curBox, item))
            {
                innerCol.RemoveAt(i);
                result = true;
                break;
            }
        }
        return result;
    }
}


// Defines the enumerator for the Boxes collection.
// (Some prefer this class nested in the collection class.)
public class BoxEnumerator : IEnumerator<Box>
{
    private BoxCollection _collection;
    private int curIndex;
    private Box curBox;

    public BoxEnumerator(BoxCollection collection)
    {
        _collection = collection;
        curIndex = -1;
        curBox = default(Box);
    }

    public bool MoveNext()
    {
        //Avoids going beyond the end of the collection.
        if (++curIndex >= _collection.Count)
        {
            return false;
        }
        else
        {
            // Set current box to next item in collection.
            curBox = _collection[curIndex];
        }
        return true;
    }

    public void Reset() { curIndex = -1; }

    void IDisposable.Dispose() { }

    public Box Current
    {
        get { return curBox; }
    }

    object IEnumerator.Current
    {
        get { return Current; }
    }
}

// Defines two boxes as equal if they have the same dimensions.
public class BoxSameDimensions : EqualityComparer<Box>
{

    public override bool Equals(Box b1, Box b2)
    {
        if (b1.Height == b2.Height && b1.Length == b2.Length
                            && b1.Width == b2.Width)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        return hCode.GetHashCode();
    }
}

// Defines two boxes as equal if they have the same volume.
public class BoxSameVol : EqualityComparer<Box>
{

    public override bool Equals(Box b1, Box b2)
    {
        if ((b1.Height * b1.Length * b1.Width) ==
                (b2.Height * b2.Length * b2.Width))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        Console.WriteLine("HC: {0}", hCode.GetHashCode());
        return hCode.GetHashCode();
    }
}


/*
This code example displays the following output:
================================================

A box with 10x4x6 dimensions was already added to the collection.

Height  Length  Width   Hash Code
10      4       6       46104728
4       6       10      12289376
6       10      4       43495525
12      8       10      55915408

Removing 6x10x4

Height  Length  Width   Hash Code
10      4       6       46104728
4       6       10      12289376
12      8       10      55915408

Contains 8x12x10 by dimensions: False
Contains 8x12x10 by volume: True
 */

Imports System.Collections
Imports System.Collections.Generic

Class Program
    Public Shared Sub Main(ByVal args() As String)

        Dim bxList As BoxCollection = New BoxCollection()

        bxList.Add(New Box(10, 4, 6))
        bxList.Add(New Box(4, 6, 10))
        bxList.Add(New Box(6, 10, 4))
        bxList.Add(New Box(12, 8, 10))

        ' Same dimensions. Cannot be added:
        bxList.Add(New Box(10, 4, 6))

        ' Test the Remove method.
        Display(bxList)
        Console.WriteLine("Removing 6x10x4")
        bxList.Remove(New Box(6, 10, 4))
        Display(bxList)

        ' Test the Contains method
        Dim BoxCheck As Box = New Box(8, 12, 10)
        Console.WriteLine("Contains {0}x{1}x{2} by dimensions: {3}", BoxCheck.Height.ToString(),
            BoxCheck.Length.ToString(), BoxCheck.Width.ToString(), bxList.Contains(BoxCheck).ToString())

        ' Test the Contains method overload with a specified equality comparer.
        Console.WriteLine("Contains {0}x{1}x{2} by volume: {3}", BoxCheck.Height.ToString(),
            BoxCheck.Length.ToString(), BoxCheck.Width.ToString(),
            bxList.Contains(BoxCheck, New BoxSameVol()).ToString())

    End Sub

    Public Shared Sub Display(ByVal bxList As BoxCollection)
        Console.WriteLine(vbLf & "Height" & vbTab & "Length" & vbTab & "Width" & vbTab & "Hash Code")
        For Each bx As Box In bxList
            Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}" & vbTab & "{3}", bx.Height.ToString(), bx.Length.ToString(), bx.Width.ToString(), bx.GetHashCode().ToString())
        Next
        Console.WriteLine()
    End Sub
End Class

Public Class Box : Implements IEquatable(Of Box)
    Public Sub New(ByVal h As Integer, ByVal l As Integer, ByVal w As Integer)
        Me.Height = h
        Me.Length = l
        Me.Width = w
    End Sub

    Private _Height As Integer
    Public Property Height() As Integer
        Get
            Return _Height
        End Get
        Set(ByVal value As Integer)
            _Height = value
        End Set
    End Property

    Private _Length As Integer
    Public Property Length() As Integer
        Get
            Return _Length
        End Get
        Set(ByVal value As Integer)
            _Length = value
        End Set
    End Property

    Private _Width As Integer
    Public Property Width() As Integer
        Get
            Return _Width
        End Get
        Set(ByVal value As Integer)
            _Width = value
        End Set
    End Property

    Public Overloads Function Equals(ByVal other As Box) As Boolean Implements IEquatable(Of Box).Equals
        Dim BoxSameDim = New BoxSameDimensions()
        If BoxSameDim.Equals(Me, other) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function Equals(ByVal obj As Object) As Boolean
        Return MyBase.Equals(obj)
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return MyBase.GetHashCode()
    End Function
End Class

Public Class BoxCollection : Implements ICollection(Of Box)
    ' The generic enumerator obtained from IEnumerator<Box> by GetEnumerator can also
    ' be used with the non-generic IEnumerator. To avoid a naming conflict, 
    ' the non-generic IEnumerable method is explicitly implemented.

    Public Function GetEnumerator() As IEnumerator(Of Box) _
        Implements IEnumerable(Of Box).GetEnumerator

        Return New BoxEnumerator(Me)
    End Function

    Private Function GetEnumerator1() As IEnumerator _
        Implements IEnumerable.GetEnumerator

        Return Me.GetEnumerator()
    End Function

    ' The inner collection to store objects.
    Private innerCol As List(Of Box)

    Public Sub New()
        innerCol = New List(Of Box)
    End Sub

    ' Adds an index to the collection.
    Default Public Property Item(ByVal index As Integer) As Box
        Get
            'If index <> -1 Then
            Return CType(innerCol(index), Box)
            'End If
            'Return Nothing
        End Get
        Set(ByVal Value As Box)
            innerCol(index) = Value
        End Set
    End Property

    ' Determines if an item is in the collection
    ' by using the BoxSameDimensions equality comparer.
    Public Function Contains(ByVal item As Box) As Boolean _
            Implements ICollection(Of Box).Contains
        Dim found As Boolean = False

        Dim bx As Box
        For Each bx In innerCol
            If New BoxSameDimensions().Equals(bx, item) Then
                found = True
            End If
        Next

        Return found
    End Function

    ' Determines if an item is in the 
    ' collection by using a specified equality comparer.
    Public Function Contains(ByVal item As Box, _
        ByVal comp As EqualityComparer(Of Box)) As Boolean
        Dim found As Boolean = False

        Dim bx As Box
        For Each bx In innerCol
            If comp.Equals(bx, item) Then
                found = True
            End If
        Next

        Return found
    End Function

    ' Adds an item if it is not already in the collection
    ' as determined by calling the Contains method.
    Public Sub Add(ByVal item As Box) _
        Implements ICollection(Of Box).Add

        If Not Me.Contains(item) Then
            innerCol.Add(item)
        Else
            Console.WriteLine("A box with {0}x{1}x{2} dimensions was already added to the collection.",
                item.Height.ToString(), item.Length.ToString(), item.Width.ToString())
        End If
    End Sub

    Public Sub Clear() Implements ICollection(Of Box).Clear
        innerCol.Clear()
    End Sub

    Public Sub CopyTo(array As Box(), arrayIndex As Integer) _
            Implements ICollection(Of Box).CopyTo
        If array Is Nothing Then
           Throw New ArgumentNullException("The array cannot be null.")
        Else If arrayIndex < 0 Then
           Throw New ArgumentOutOfRangeException("The starting array index cannot be negative.")
        Else If Count > array.Length - arrayIndex + 1 Then
           Throw New ArgumentException("The destination array has fewer elements than the collection.")
        End If
        
        For i As Integer = 0 To innerCol.Count - 1
            array(i + arrayIndex) = innerCol(i)
        Next
    End Sub

    Public ReadOnly Property Count() As Integer _
            Implements ICollection(Of Box).Count
        Get
            Return innerCol.Count
        End Get
    End Property

    Public ReadOnly Property IsReadOnly() As Boolean _
           Implements ICollection(Of Box).IsReadOnly
        Get
            Return False
        End Get
    End Property

    Public Function Remove(ByVal item As Box) As Boolean _
            Implements ICollection(Of Box).Remove
        Dim result As Boolean = False

        ' Iterate the inner collection to 
        ' find the box to be removed.

        Dim i As Integer
        For i = 0 To innerCol.Count - 1

            Dim curBox As Box = CType(innerCol(i), Box)

            If New BoxSameDimensions().Equals(curBox, item) Then
                innerCol.RemoveAt(i)
                result = True
                Exit For
            End If
        Next
        Return result
    End Function
End Class

' Defines the enumerator for the Boxes collection.
' (Some prefer this class nested in the collection class.)
Public Class BoxEnumerator
    Implements IEnumerator(Of Box)
    Private _collection As BoxCollection
    Private curIndex As Integer
    Private curBox As Box


    Public Sub New(ByVal collection As BoxCollection)
        MyBase.New()
        _collection = collection
        curIndex = -1
        curBox = Nothing

    End Sub

    Private Property Box As Box
    Public Function MoveNext() As Boolean _
        Implements IEnumerator(Of Box).MoveNext
        curIndex = curIndex + 1
        If curIndex = _collection.Count Then
            ' Avoids going beyond the end of the collection.
            Return False
        Else
            'Set current box to next item in collection.
            curBox = _collection(curIndex)
        End If
        Return True
    End Function

    Public Sub Reset() _
        Implements IEnumerator(Of Box).Reset
        curIndex = -1
    End Sub

    Public Sub Dispose() _
        Implements IEnumerator(Of Box).Dispose

    End Sub

    Public ReadOnly Property Current() As Box _
        Implements IEnumerator(Of Box).Current

        Get
            If curBox Is Nothing Then
                Throw New InvalidOperationException()
            End If

            Return curBox
        End Get
    End Property

    Private ReadOnly Property Current1() As Object _
        Implements IEnumerator.Current

        Get
            Return Me.Current
        End Get
    End Property
End Class

' Defines two boxes as equal if they have the same dimensions.
Public Class BoxSameDimensions
    Inherits EqualityComparer(Of Box)

    Public Overrides Function Equals(ByVal b1 As Box, ByVal b2 As Box) As Boolean
        If b1.Height = b2.Height And b1.Length = b2.Length And b1.Width = b2.Width Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function GetHashCode(ByVal bx As Box) As Integer
        Dim hCode As Integer = bx.Height ^ bx.Length ^ bx.Width
        Return hCode.GetHashCode()
    End Function
End Class

' Defines two boxes as equal if they have the same volume.
Public Class BoxSameVol
    Inherits EqualityComparer(Of Box)

    Public Overrides Function Equals(ByVal b1 As Box, ByVal b2 As Box) As Boolean
        If (b1.Height * b1.Length * b1.Width) _
            = (b2.Height * b2.Length * b2.Width) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function GetHashCode(ByVal bx As Box) As Integer
        Dim hCode As Integer = bx.Height ^ bx.Length ^ bx.Width
        Console.WriteLine("HC: {0}", hCode.GetHashCode())
        Return hCode.GetHashCode()
    End Function
End Class


'  This code example displays the following output:
'  ================================================
'
'  A box with 10x4x6 dimensions was already added to the collection.
'
'  Height  Length  Width   Hash Code
'  10      4       6       46104728
'  4       6       10      12289376
'  6       10      4       43495525
'  12      8       10      55915408
'
'  Removing 6x10x4
'
'  Height  Length  Width   Hash Code
'  10      4       6       46104728
'  4       6       10      12289376
'  12      8       10      55915408
'
'  Contains 8x12x10 by dimensions: False
'  Contains 8x12x10 by volume: True
'

Uwagi

Interfejs ICollection<T> jest podstawowym interfejsem dla klas w System.Collections.Generic przestrzeni nazw.

Interfejs ICollection<T> rozszerza IEnumerable<T>interfejs ; IDictionary<TKey,TValue> i IList<T> są bardziej wyspecjalizowanymi interfejsami, które rozszerzają ICollection<T>element . Implementacja IDictionary<TKey,TValue> to kolekcja par klucz/wartość, takich jak Dictionary<TKey,TValue> klasa. Implementacja IList<T> jest kolekcją wartości, a jej składowe mogą być dostępne według indeksu List<T> , takiego jak klasa.

Jeśli interfejs ani IList<T> interfejs nie IDictionary<TKey,TValue> spełniają wymagań wymaganej kolekcji, utwórz nową klasę kolekcji z interfejsuICollection<T>, aby uzyskać większą elastyczność.

Właściwości

Count	Pobiera liczbę elementów zawartych w słowniku ICollection<T>.
IsReadOnly	Pobiera wartość wskazującą, czy kolekcja ICollection<T> jest przeznaczona tylko do odczytu.

Metody

Add(T)	Dodaje element do elementu ICollection<T>.
Clear()	Usuwa wszystkie elementy z elementu ICollection<T>.
Contains(T)	Określa, czy element ICollection<T> zawiera określoną wartość.
CopyTo(T[], Int32)	Kopiuje elementy ICollection<T> elementu do obiektu Array, zaczynając od określonego Array indeksu.
GetEnumerator()	Zwraca moduł wyliczający, który iteruje po kolekcji. (Odziedziczone po IEnumerable)
Remove(T)	Usuwa pierwsze wystąpienie określonego obiektu z obiektu ICollection<T>.

Metody rozszerzania

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element FrozenDictionary<TKey,TValue>IEnumerable<T> na podstawie określonej funkcji selektora kluczy.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element FrozenDictionary<TKey,TValue>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Tworzy element FrozenSet<T> z określonymi wartościami.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Tworzy niezmienną tablicę z określonej kolekcji.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy niezmienny słownik z istniejącej kolekcji elementów, stosując funkcję przekształcania do kluczy źródłowych.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy niezmienny słownik na podstawie pewnej transformacji sekwencji.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości przy użyciu określonego modułu porównywania kluczy.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienny zestaw skrótów jego zawartości.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Wylicza sekwencję, tworzy niezmienny zestaw skrótów jego zawartości i używa określonego porównania równości dla typu zestawu.
ToImmutableList<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienną listę jego zawartości.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonego modułu porównywania kluczy.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienny zestaw posortowany jego zawartości.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Wylicza sekwencję, tworzy niezmienny zestaw posortowany jego zawartości i używa określonego porównania.
CopyToDataTable<T>(IEnumerable<T>)	Zwraca element DataTable zawierający kopie DataRow obiektów, biorąc pod uwagę obiekt wejściowy IEnumerable<T> , w którym parametr `T` ogólny to DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr `T` ogólny to DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr `T` ogólny to DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Stosuje funkcję akumulatora po sekwencji.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Stosuje funkcję akumulatora po sekwencji. Określona wartość nasion jest używana jako początkowa wartość akumulatorowa.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Stosuje funkcję akumulatora po sekwencji. Określona wartość inicjowania jest używana jako początkowa wartość akumulatora, a określona funkcja jest używana do wybierania wartości wyniku.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Definiuje metody manipulowania kolekcjami ogólnymi.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Definiuje metody manipulowania kolekcjami ogólnymi.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Określa, czy wszystkie elementy sekwencji spełniają warunek.
Any<TSource>(IEnumerable<TSource>)	Określa, czy sekwencja zawiera jakiekolwiek elementy.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Określa, czy dowolny element sekwencji spełnia warunek.
Append<TSource>(IEnumerable<TSource>, TSource)	Dołącza wartość na końcu sekwencji.
AsEnumerable<TSource>(IEnumerable<TSource>)	Zwraca dane wejściowe wpisane jako IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Oblicza średnią sekwencji Decimal wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Oblicza średnią sekwencji Double wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Oblicza średnią sekwencji Int32 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Oblicza średnią sekwencji Int64 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Decimal przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Double przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Int32 przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Int64 przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Single przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Oblicza średnią sekwencji Single wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Cast<TResult>(IEnumerable)	Rzutuje elementy elementu IEnumerable do określonego typu.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Dzieli elementy sekwencji na fragmenty rozmiaru w większości `size`.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Łączy dwie sekwencje.
Contains<TSource>(IEnumerable<TSource>, TSource)	Określa, czy sekwencja zawiera określony element przy użyciu domyślnego porównywania równości.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Określa, czy sekwencja zawiera określony element przy użyciu określonego IEqualityComparer<T>elementu .
Count<TSource>(IEnumerable<TSource>)	Zwraca liczbę elementów w sekwencji.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca liczbę reprezentującą, ile elementów w określonej sekwencji spełnia warunek.
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Definiuje metody manipulowania kolekcjami ogólnymi.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Zwraca elementy określonej sekwencji lub wartość domyślną parametru typu w kolekcji pojedynczej, jeśli sekwencja jest pusta.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Zwraca elementy określonej sekwencji lub określoną wartość w kolekcji pojedynczej, jeśli sekwencja jest pusta.
Distinct<TSource>(IEnumerable<TSource>)	Zwraca różne elementy z sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Zwraca różne elementy z sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównywania wartości.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy i przy użyciu określonego porównania kluczy.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Zwraca element w określonym indeksie w sekwencji.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Zwraca element w określonym indeksie w sekwencji.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy różnicę zestawu dwóch sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy różnicę zestawu dwóch sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównania wartości.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
First<TSource>(IEnumerable<TSource>)	Zwraca pierwszy element sekwencji.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca pierwszy element w sekwencji, który spełnia określony warunek.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Zwraca pierwszy element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca pierwszy element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca pierwszy element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca pierwszy element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i porównuje klucze przy użyciu określonego porównania.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i projektuje elementy dla każdej grupy przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z funkcją selektora kluczy. Klucze są porównywane przy użyciu modułu porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Klucze są porównywane przy użyciu określonego porównania.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Wartości klucza są porównywane przy użyciu określonego porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Koreluje elementy dwóch sekwencji na podstawie równości kluczy i grupuje wyniki. Domyślny moduł porównywania równości służy do porównywania kluczy.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Koreluje elementy dwóch sekwencji na podstawie równości klucza i grupuje wyniki. Określony IEqualityComparer<T> jest używany do porównywania kluczy.
Index<TSource>(IEnumerable<TSource>)	Definiuje metody manipulowania kolekcjami ogólnymi.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy przecięcie zestawu dwóch sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy przecięcie zestawu dwóch sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównania wartości.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Domyślny moduł porównywania równości służy do porównywania kluczy.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Określony IEqualityComparer<T> jest używany do porównywania kluczy.
Last<TSource>(IEnumerable<TSource>)	Zwraca ostatni element sekwencji.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca ostatni element sekwencji, który spełnia określony warunek.
LastOrDefault<TSource>(IEnumerable<TSource>)	Zwraca ostatni element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca ostatni element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca ostatni element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca ostatni element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.
LongCount<TSource>(IEnumerable<TSource>)	Zwraca element Int64 reprezentujący całkowitą liczbę elementów w sekwencji.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca element Int64 reprezentujący liczbę elementów w sekwencji spełniających warunek.
Max<TSource>(IEnumerable<TSource>)	Zwraca maksymalną wartość w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Zwraca maksymalną wartość w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Decimal wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Double wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int32 wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int64 wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Decimal do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Double do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int32 do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int64 do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Single do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Single wartość.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca maksymalną wynikową wartość.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.
Min<TSource>(IEnumerable<TSource>)	Zwraca wartość minimalną w sekwencji ogólnej.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Zwraca wartość minimalną w sekwencji ogólnej.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Decimal do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Double do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int32 do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int64 do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Single do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Single .
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca minimalną wynikową wartość.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.
OfType<TResult>(IEnumerable)	Filtruje elementy elementu IEnumerable na podstawie określonego typu.
Order<T>(IEnumerable<T>)	Sortuje elementy sekwencji w kolejności rosnącej.
Order<T>(IEnumerable<T>, IComparer<T>)	Sortuje elementy sekwencji w kolejności rosnącej.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortuje elementy sekwencji w kolejności rosnącej zgodnie z kluczem.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortuje elementy sekwencji w kolejności rosnącej przy użyciu określonego porównania.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortuje elementy sekwencji w kolejności malejącej zgodnie z kluczem.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortuje elementy sekwencji w kolejności malejącej przy użyciu określonego porównania.
OrderDescending<T>(IEnumerable<T>)	Sortuje elementy sekwencji w kolejności malejącej.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Sortuje elementy sekwencji w kolejności malejącej.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Dodaje wartość na początku sekwencji.
Reverse<TSource>(IEnumerable<TSource>)	Odwraca kolejność elementów w sekwencji.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projektuje każdy element sekwencji w nowym formularzu.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projektuje każdy element sekwencji w nowym formularzu, dołączając indeks elementu.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projektuje każdy element sekwencji do IEnumerable<T> elementu i spłaszcza wynikowe sekwencje w jedną sekwencję.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu i spłaszcza wynikowe sekwencje w jedną sekwencję. Indeks każdego elementu źródłowego jest używany w przewidywanej formie tego elementu.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym elemecie.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym elemecie. Indeks każdego elementu źródłowego jest używany w przewidywanej formie pośredniej tego elementu.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Określa, czy dwie sekwencje są równe, porównując elementy przy użyciu domyślnego porównywarki równości dla ich typu.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Określa, czy dwie sekwencje są równe, porównując swoje elementy przy użyciu określonego IEqualityComparer<T>elementu .
Single<TSource>(IEnumerable<TSource>)	Zwraca jedyny element sekwencji i zgłasza wyjątek, jeśli nie ma dokładnie jednego elementu w sekwencji.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca jedyny element sekwencji, który spełnia określony warunek, i zgłasza wyjątek, jeśli istnieje więcej niż jeden taki element.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Zwraca jedyny element sekwencji lub wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli w sekwencji znajduje się więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca jedyny element sekwencji lub określoną wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli w sekwencji znajduje się więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca jedyny element sekwencji, który spełnia określony warunek lub wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca jedyny element sekwencji, który spełnia określony warunek lub określoną wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.
Skip<TSource>(IEnumerable<TSource>, Int32)	Pomija określoną liczbę elementów w sekwencji, a następnie zwraca pozostałe elementy.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Zwraca nową kolekcję wyliczalną zawierającą elementy z `source` ostatnich `count` elementów kolekcji źródłowej pominiętą.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy. Indeks elementu jest używany w logice funkcji predykatu.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Oblicza sumę sekwencji Decimal wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Oblicza sumę sekwencji Double wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Oblicza sumę sekwencji Int32 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Oblicza sumę sekwencji Int64 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Oblicza sumę sekwencji wartości null, które są uzyskiwane Decimal przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza sumę sekwencji wartości null, które są uzyskiwane Double przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza sumę sekwencji wartości null, które są uzyskiwane Int32 przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza sumę sekwencji wartości null, które są uzyskiwane Int64 przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza sumę sekwencji wartości null, które są uzyskiwane Single przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Oblicza sumę sekwencji Single wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Take<TSource>(IEnumerable<TSource>, Int32)	Zwraca określoną liczbę ciągłych elementów od początku sekwencji.
Take<TSource>(IEnumerable<TSource>, Range)	Zwraca określony zakres ciągłych elementów z sekwencji.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Zwraca nową kolekcję wyliczalną zawierającą ostatnie `count` elementy z `source`elementu .
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca elementy z sekwencji, o ile określony warunek jest spełniony.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Zwraca elementy z sekwencji, o ile określony warunek jest spełniony. Indeks elementu jest używany w logice funkcji predykatu.
ToArray<TSource>(IEnumerable<TSource>)	Tworzy tablicę na podstawie elementu IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy element Dictionary<TKey,TValue> na podstawie IEnumerable<T> określonej funkcji selektora kluczy.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element Dictionary<TKey,TValue> na podstawie IEnumerable<T> określonej funkcji selektora kluczy i modułu porównywania kluczy.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy element Dictionary<TKey,TValue>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element Dictionary<TKey,TValue> na IEnumerable<T> podstawie określonej funkcji selektora kluczy, modułu porównania i funkcji selektora elementów.
ToHashSet<TSource>(IEnumerable<TSource>)	Tworzy obiekt na HashSet<T> podstawie elementu IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy obiekt HashSet<T>IEnumerable<T> na podstawie polecenia , `comparer` aby porównać klucze.
ToList<TSource>(IEnumerable<TSource>)	Tworzy obiekt na List<T> podstawie elementu IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy i modułu porównywania kluczy.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy element Lookup<TKey,TElement>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy, funkcji selektora elementów i selektora elementów.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Próbuje określić liczbę elementów w sekwencji bez wymuszania wyliczenia.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy unię zestawu dwóch sekwencji przy użyciu domyślnego porównywania równości.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy unię zestawu dwóch sekwencji przy użyciu określonego IEqualityComparer<T>elementu .
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy unię zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy unię zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtruje sekwencję wartości na podstawie predykatu.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtruje sekwencję wartości na podstawie predykatu. Indeks każdego elementu jest używany w logice funkcji predykatu.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Tworzy sekwencję krotki z elementami z dwóch określonych sekwencji.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Tworzy sekwencję krotki z elementami z trzech określonych sekwencji.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Stosuje określoną funkcję do odpowiednich elementów dwóch sekwencji, tworząc sekwencję wyników.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsParallel<TSource>(IEnumerable<TSource>)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje element IEnumerable na .IQueryable
AsQueryable<TElement>(IEnumerable<TElement>)	Konwertuje rodzajowy IEnumerable<T> na ogólny IQueryable<T>.
Ancestors<T>(IEnumerable<T>)	Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego węzła w kolekcji źródłowej.
Ancestors<T>(IEnumerable<T>, XName)	Zwraca przefiltrowaną kolekcję elementów, które zawierają elementy będące elementami głównymi każdego węzła w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
DescendantNodes<T>(IEnumerable<T>)	Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.
Descendants<T>(IEnumerable<T>)	Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.
Descendants<T>(IEnumerable<T>, XName)	Zwraca filtrowaną kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
Elements<T>(IEnumerable<T>)	Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.
Elements<T>(IEnumerable<T>, XName)	Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
InDocumentOrder<T>(IEnumerable<T>)	Zwraca kolekcję węzłów zawierającą wszystkie węzły w kolekcji źródłowej posortowane w kolejności dokumentu.
Nodes<T>(IEnumerable<T>)	Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.
Remove<T>(IEnumerable<T>)	Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.

Dotyczy