IEnumerable<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.

Uwidacznia moduł wyliczający, który obsługuje prostą iterację w kolekcji określonego typu.

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

public interface IEnumerable<out T> : System.Collections.IEnumerable

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

type seq<'T> = interface
    interface IEnumerable

Public Interface IEnumerable(Of Out T)
Implements IEnumerable

Public Interface IEnumerable(Of T)
Implements IEnumerable

Parametry typu

T

Typ obiektów do wyliczenia.

Ten parametr typu jest kowariantny. Oznacza to, że możesz użyć typu, który został przez Ciebie określony, lub dowolnego typu, który jest bardziej pochodny. Aby uzyskać więcej informacji o kowariancji i kontrawariancji, zobacz Kowariancja i kontrawariancja w typach ogólnych.

Pochodne: Microsoft.Extensions.Configuration.Memory.MemoryConfigurationProvider

Microsoft.Extensions.DependencyInjection.IServiceCollection

Microsoft.Extensions.DependencyInjection.ServiceCollection

Microsoft.Extensions.FileProviders.Composite.CompositeDirectoryContents

Microsoft.Extensions.FileProviders.IDirectoryContents

Więcej…

Implementuje: IEnumerable

Przykłady

W poniższym przykładzie pokazano, jak zaimplementować interfejs IEnumerable<T> i jak używać tej implementacji do tworzenia zapytania LINQ. Podczas implementowania IEnumerable<T>należy również zaimplementować IEnumerator<T> lub tylko dla języka C# można użyć słowa kluczowego. Zaimplementowanie IEnumerator<T> wymaga również zaimplementowania IDisposable, co zostanie wyświetlone w tym przykładzie.

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class App
{
    // Exercise the Iterator and show that it's more
    // performant.
    public static void Main()
    {
        TestStreamReaderEnumerable();
        Console.WriteLine("---");
        TestReadingFile();
    }

    public static void TestStreamReaderEnumerable()
    {
        // Check the memory before the iterator is used.
        long memoryBefore = GC.GetTotalMemory(true);
      IEnumerable<String> stringsFound;
        // Open a file with the StreamReaderEnumerable and check for a string.
      try {
         stringsFound =
               from line in new StreamReaderEnumerable(@"c:\temp\tempFile.txt")
               where line.Contains("string to search for")
               select line;
         Console.WriteLine("Found: " + stringsFound.Count());
      }
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
      }

        // Check the memory after the iterator and output it to the console.
        long memoryAfter = GC.GetTotalMemory(false);
        Console.WriteLine("Memory Used With Iterator = \t"
            + string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
    }

    public static void TestReadingFile()
    {
        long memoryBefore = GC.GetTotalMemory(true);
      StreamReader sr;
      try {
         sr = File.OpenText("c:\\temp\\tempFile.txt");
      }
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
      }

        // Add the file contents to a generic list of strings.
        List<string> fileContents = new List<string>();
        while (!sr.EndOfStream) {
            fileContents.Add(sr.ReadLine());
        }

        // Check for the string.
        var stringsFound =
            from line in fileContents
            where line.Contains("string to search for")
            select line;

        sr.Close();
        Console.WriteLine("Found: " + stringsFound.Count());

        // Check the memory after when the iterator is not used, and output it to the console.
        long memoryAfter = GC.GetTotalMemory(false);
        Console.WriteLine("Memory Used Without Iterator = \t" +
            string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
    }
}

// A custom class that implements IEnumerable(T). When you implement IEnumerable(T),
// you must also implement IEnumerable and IEnumerator(T).
public class StreamReaderEnumerable : IEnumerable<string>
{
    private string _filePath;
    public StreamReaderEnumerable(string filePath)
    {
        _filePath = filePath;
    }

    // Must implement GetEnumerator, which returns a new StreamReaderEnumerator.
    public IEnumerator<string> GetEnumerator()
    {
        return new StreamReaderEnumerator(_filePath);
    }

    // Must also implement IEnumerable.GetEnumerator, but implement as a private method.
    private IEnumerator GetEnumerator1()
    {
        return this.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator1();
    }
}

// When you implement IEnumerable(T), you must also implement IEnumerator(T),
// which will walk through the contents of the file one line at a time.
// Implementing IEnumerator(T) requires that you implement IEnumerator and IDisposable.
public class StreamReaderEnumerator : IEnumerator<string>
{
    private StreamReader _sr;
    public StreamReaderEnumerator(string filePath)
    {
        _sr = new StreamReader(filePath);
    }

    private string _current;
    // Implement the IEnumerator(T).Current publicly, but implement
    // IEnumerator.Current, which is also required, privately.
    public string Current
    {

        get
        {
            if (_sr == null || _current == null)
            {
                throw new InvalidOperationException();
            }

            return _current;
        }
    }

    private object Current1
    {

        get { return this.Current; }
    }

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

    // Implement MoveNext and Reset, which are required by IEnumerator.
    public bool MoveNext()
    {
        _current = _sr.ReadLine();
        if (_current == null)
            return false;
        return true;
    }

    public void Reset()
    {
        _sr.DiscardBufferedData();
        _sr.BaseStream.Seek(0, SeekOrigin.Begin);
        _current = null;
    }

    // Implement IDisposable, which is also implemented by IEnumerator(T).
    private bool disposedValue = false;
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposedValue)
        {
            if (disposing)
            {
                // Dispose of managed resources.
            }
            _current = null;
            if (_sr != null) {
               _sr.Close();
               _sr.Dispose();
            }
        }

        this.disposedValue = true;
    }

     ~StreamReaderEnumerator()
    {
        Dispose(disposing: false);
    }
}
// This example displays output similar to the following:
//       Found: 2
//       Memory Used With Iterator =     33kb
//       ---
//       Found: 2
//       Memory Used Without Iterator =  206kb

Imports System.IO
Imports System.Collections
Imports System.Collections.Generic
Imports System.Linq

Public Module App
   ' Excercise the Iterator and show that it's more performant.
   Public Sub Main()
      TestStreamReaderEnumerable()
      Console.WriteLine("---")
      TestReadingFile()
   End Sub

   Public Sub TestStreamReaderEnumerable()
        ' Check the memory before the iterator is used.
        Dim memoryBefore As Long = GC.GetTotalMemory(true)
      Dim stringsFound As IEnumerable(Of String)
        ' Open a file with the StreamReaderEnumerable and check for a string.
      Try
         stringsFound =
               from line in new StreamReaderEnumerable("c:\temp\tempFile.txt")
               where line.Contains("string to search for")
               select line
         Console.WriteLine("Found: {0}", stringsFound.Count())
      Catch e As FileNotFoundException
         Console.WriteLine("This example requires a file named C:\temp\tempFile.txt.")
         Return
      End Try

        ' Check the memory after the iterator and output it to the console.
        Dim memoryAfter As Long = GC.GetTotalMemory(false)
        Console.WriteLine("Memory Used with Iterator = {1}{0} kb",
                        (memoryAfter - memoryBefore)\1000, vbTab)
   End Sub

   Public Sub TestReadingFile()
        Dim memoryBefore As Long = GC.GetTotalMemory(true)
      Dim sr As StreamReader
      Try
         sr = File.OpenText("c:\temp\tempFile.txt")
      Catch e As FileNotFoundException
         Console.WriteLine("This example requires a file named C:\temp\tempFile.txt.")
         Return
      End Try

        ' Add the file contents to a generic list of strings.
        Dim fileContents As New List(Of String)()
        Do While Not sr.EndOfStream
            fileContents.Add(sr.ReadLine())
      Loop

        ' Check for the string.
        Dim stringsFound =
            from line in fileContents
            where line.Contains("string to search for")
            select line

      sr.Close()
      Console.WriteLine("Found: {0}", stringsFound.Count())

        ' Check the memory after when the iterator is not used, and output it to the console.
        Dim memoryAfter As Long = GC.GetTotalMemory(False)
        Console.WriteLine("Memory Used without Iterator = {1}{0} kb",
                        (memoryAfter - memoryBefore)\1000, vbTab)
   End Sub
End Module

' A custom class that implements IEnumerable(T). When you implement IEnumerable(T),
' you must also implement IEnumerable and IEnumerator(T).
Public Class StreamReaderEnumerable : Implements IEnumerable(Of String)
    Private _filePath As String

    Public Sub New(filePath As String)
        _filePath = filePath
    End Sub

    ' Must implement GetEnumerator, which returns a new StreamReaderEnumerator.
    Public Function GetEnumerator() As IEnumerator(Of String) _
          Implements IEnumerable(Of String).GetEnumerator
        Return New StreamReaderEnumerator(_filePath)
    End Function

    ' Must also implement IEnumerable.GetEnumerator, but implement as a private method.
    Private Function GetEnumerator1() As IEnumerator _
          Implements IEnumerable.GetEnumerator
        Return Me.GetEnumerator()
    End Function
End Class

' When you implement IEnumerable(T), you must also implement IEnumerator(T),
' which will walk through the contents of the file one line at a time.
' Implementing IEnumerator(T) requires that you implement IEnumerator and IDisposable.
Public Class StreamReaderEnumerator : Implements IEnumerator(Of String)
    Private _sr As StreamReader

    Public Sub New(filePath As String)
        _sr = New StreamReader(filePath)
    End Sub

    Private _current As String

    ' Implement the IEnumerator(T).Current Publicly, but implement
    ' IEnumerator.Current, which is also required, privately.
    Public ReadOnly Property Current As String _
          Implements IEnumerator(Of String).Current
        Get
            If _sr Is Nothing OrElse _current Is Nothing
                Throw New InvalidOperationException()
            End If

            Return _current
        End Get
    End Property

    Private ReadOnly Property Current1 As Object _
          Implements IEnumerator.Current
        Get
           Return Me.Current
        End Get
    End Property

    ' Implement MoveNext and Reset, which are required by IEnumerator.
    Public Function MoveNext() As Boolean _
          Implements IEnumerator.MoveNext
        _current = _sr.ReadLine()
        if _current Is Nothing Then Return False

        Return True
    End Function

    Public Sub Reset() _
          Implements IEnumerator.Reset
        _sr.DiscardBufferedData()
        _sr.BaseStream.Seek(0, SeekOrigin.Begin)
        _current = Nothing
    End Sub

    ' Implement IDisposable, which is also implemented by IEnumerator(T).
    Private disposedValue As Boolean = False
    Public Sub Dispose() _
          Implements IDisposable.Dispose
        Dispose(disposing:=True)
        GC.SuppressFinalize(Me)
    End Sub

    Protected Overridable Sub Dispose(disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                ' Dispose of managed resources.
            End If

            _current = Nothing
            If _sr IsNot Nothing Then
               _sr.Close()
               _sr.Dispose()
            End If
        End If

        Me.disposedValue = True
    End Sub

    Protected Overrides Sub Finalize()
        Dispose(disposing:=False)
    End Sub
End Class
' This example displays output similar to the following:
'       Found: 2
'       Memory Used With Iterator =     33kb
'       ---
'       Found: 2
'       Memory Used Without Iterator =  206kb

Uwagi

IEnumerable<T> to podstawowy interfejs kolekcji w przestrzeni nazw System.Collections.Generic, takiej jak List<T>, Dictionary<TKey,TValue>i Stack<T> oraz inne kolekcje ogólne, takie jak ObservableCollection<T> i ConcurrentStack<T>. Kolekcje implementujące IEnumerable<T> można wyliczyć przy użyciu instrukcji foreach.

Aby uzyskać niegeneryjną wersję tego interfejsu, zobacz System.Collections.IEnumerable.

IEnumerable<T> zawiera jedną metodę, którą należy zaimplementować podczas implementowania tego interfejsu; GetEnumerator, który zwraca obiekt IEnumerator<T>. Zwrócony IEnumerator<T> umożliwia iterowanie kolekcji przez uwidacznianie właściwości Current.

Uwagi dotyczące implementowania

Aby zachować zgodność z metodami, które iterują kolekcje inne niż ogólne, IEnumerable<T> implementuje IEnumerable. Umożliwia to przekazanie kolekcji ogólnej do metody, która oczekuje obiektu IEnumerable.

Metody

GetEnumerator()

Zwraca moduł wyliczający, który iteruje za pośrednictwem kolekcji.

Metody rozszerzania

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy FrozenDictionary<TKey,TValue> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy FrozenDictionary<TKey,TValue> z IEnumerable<T> zgodnie z określonymi funkcjami selektora kluczy i selektora elementów.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Tworzy 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 niektórych przekształceń sekwencji.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Wylicza i przekształca sekwencję oraz 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 porównania kluczy.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję oraz 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 porównania kluczy.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję oraz 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 posortowany zestaw jego zawartości.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Wylicza sekwencję, tworzy niezmienialny zestaw posortowany jego zawartości i używa określonego porównania.
CopyToDataTable<T>(IEnumerable<T>)	Zwraca DataTable, który zawiera kopie obiektów DataRow, biorąc pod uwagę obiekt wejściowy IEnumerable<T>, w którym parametr ogólny `T` jest DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Kopiuje obiekty DataRow do określonego DataTable, biorąc pod uwagę obiekt wejściowy IEnumerable<T>, w którym parametr ogólny `T` jest DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Kopiuje obiekty DataRow do określonego DataTable, biorąc pod uwagę obiekt wejściowy IEnumerable<T>, w którym parametr ogólny `T` jest DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Stosuje funkcję akumulatorową w sekwencji.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Stosuje funkcję akumulatorową w sekwencji. Określona wartość inicju jest używana jako początkowa wartość akumulatorowa.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Stosuje funkcję akumulatorową w sekwencji. Określona wartość inicjatora jest używana jako początkowa wartość akumulowania, a określona funkcja służy do wybierania wartości wyniku.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Uwidacznia moduł wyliczający, który obsługuje prostą iterację w kolekcji określonego typu.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Uwidacznia moduł wyliczający, który obsługuje prostą iterację w kolekcji określonego typu.
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 Decimal, które są uzyskiwane przez wywołanie funkcji transform w każdym elemecie sekwencji wejściowej.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null Double, które są uzyskiwane przez wywołanie funkcji transform w każdym elemecie sekwencji wejściowej.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null Int32, które są uzyskiwane przez wywołanie funkcji transform w każdym elemecie sekwencji wejściowej.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null Int64, które są uzyskiwane przez wywołanie funkcji transform w każdym elemecie sekwencji wejściowej.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null Single, które są uzyskiwane przez wywołanie funkcji transform w każdym elemecie sekwencji wejściowej.
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 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 modułu 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>.
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>)	Uwidacznia moduł wyliczający, który obsługuje prostą iterację w kolekcji określonego typu.
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 modułu 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ślonego IEqualityComparer<T> do porównywania wartości.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca odrębne 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 modułu porównującego do porównywania 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ślonego IEqualityComparer<T> do porównywania 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 klucza. Klucze są porównywane przy użyciu modułu porównującego, a elementy każdej grupy są projektowane 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ą funkcją selektora kluczy i tworzy wartość wynikową z każdej grupy i jej klucza.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i tworzy wartość wynikową z każdej grupy i jej 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ą funkcją selektora kluczy i tworzy wartość wynikową z każdej grupy i jej klucza. Elementy każdej grupy są projektowane 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ą funkcją selektora kluczy i tworzy wartość wynikową z każdej grupy i jej 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> służy do porównywania kluczy.
Index<TSource>(IEnumerable<TSource>)	Zwraca wyliczenie, które uwzględnia indeks elementu w krotkę.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy przecięcie zestawu dwóch sekwencji przy użyciu domyślnego modułu 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ślonego IEqualityComparer<T> do porównywania 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> służy 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 Int64 reprezentującą łączną liczbę elementów w sekwencji.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca Int64 reprezentującą liczbę elementów w sekwencji spełniających warunek.
Max<TSource>(IEnumerable<TSource>)	Zwraca wartość maksymalną w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Zwraca wartość maksymalną w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość Decimal.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość Double.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość Int32.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość Int64.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną do wartości null Decimal.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną do wartości null Double.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną do wartości null Int32.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną do wartości null Int64.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną do wartości null Single.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość Single.
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 minimalną wartość Decimal.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość Double.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość Int32.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość Int64.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną do wartości null Decimal.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną do wartości null Double.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną do wartości null Int32.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną do wartości null Int64.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną do wartości null Single.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość Single.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Wywołuje funkcję przekształcania 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ównania kluczy.
OfType<TResult>(IEnumerable)	Filtruje elementy 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 modułu 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>>)	Rzutuje każdy element sekwencji na IEnumerable<T> i spłaszcza sekwencje wynikowe w jedną sekwencję.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projektuje każdy element sekwencji do IEnumerable<T>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>, spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym z nich.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projektuje każdy element sekwencji do IEnumerable<T>, spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym z nich. Indeks każdego elementu źródłowego jest używany w pośredniej przewidywanej formie 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ównania 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 ich elementy przy użyciu określonej IEqualityComparer<T>.
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` z ostatnią `count` elementów pominiętej kolekcji źródłowej.
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 transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Oblicza sumę sekwencji Double wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Oblicza sumę sekwencji Int32 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Oblicza sumę sekwencji Int64 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null Decimal, które są uzyskiwane przez wywołanie funkcji transform w poszczególnych elementach sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null Double, które są uzyskiwane przez wywołanie funkcji transform w poszczególnych elementach sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null Int32, które są uzyskiwane przez wywołanie funkcji transform w poszczególnych elementach sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null Int64, które są uzyskiwane przez wywołanie funkcji transform w poszczególnych elementach sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null Single, które są uzyskiwane przez wywołanie funkcji transform w poszczególnych elementach sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Oblicza sumę sekwencji Single wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie 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 elementy `count` z `source`.
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 IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy Dictionary<TKey,TValue> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy Dictionary<TKey,TValue> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy i modułem porównania kluczy.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy Dictionary<TKey,TValue> z IEnumerable<T> zgodnie z określonymi funkcjami selektora kluczy i selektora elementów.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy Dictionary<TKey,TValue> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy, modułem porównania i funkcją selektora elementów.
ToHashSet<TSource>(IEnumerable<TSource>)	Tworzy HashSet<T> na podstawie IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy HashSet<T> na podstawie IEnumerable<T> przy użyciu `comparer` do porównywania kluczy.
ToList<TSource>(IEnumerable<TSource>)	Tworzy List<T> na podstawie IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy Lookup<TKey,TElement> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy Lookup<TKey,TElement> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy i modułem porównania kluczy.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy Lookup<TKey,TElement> z IEnumerable<T> zgodnie z określonymi funkcjami selektora kluczy i selektora elementów.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy Lookup<TKey,TElement> na podstawie IEnumerable<T> zgodnie z określoną funkcją selektora kluczy, modułem porównującym i funkcją 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 zestaw unii dwóch sekwencji przy użyciu domyślnego porównania równości.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy zbiór dwóch sekwencji przy użyciu określonej IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy zestaw unii dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy zestaw unii 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 IEnumerable na IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Konwertuje ogólny 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 odfiltrowaną kolekcję elementów, które zawierają elementy podrzędne każdego węzła w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają pasujący 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ą pasujący 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 odfiltrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają pasujący XName.
InDocumentOrder<T>(IEnumerable<T>)	Zwraca kolekcję węzłów, która zawiera 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

Zobacz też

IEnumerator<T>
System.Collections
przewodnik : implementowanie funkcji IEnumerable(Of T) w języku Visual Basic
iteratorów (C#)
Iteratory (Visual Basic)

Udostępnij za pośrednictwem