Queue<T> Klasa

Definicja

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

generic <typename T>
public ref class Queue : System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
generic <typename T>
public ref class Queue : System::Collections::Generic::IEnumerable<T>, System::Collections::ICollection
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection
type Queue<'T> = class
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyCollection<'T>
    interface ICollection
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Queue<'T> = class
    interface seq<'T>
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Queue<'T> = class
    interface seq<'T>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<'T>
type Queue<'T> = class
    interface seq<'T>
    interface ICollection
    interface IEnumerable
Public Class Queue(Of T)
Implements ICollection, IEnumerable(Of T), IReadOnlyCollection(Of T)
Public Class Queue(Of T)
Implements ICollection, IEnumerable(Of T)

Parametry typu

T

Określa typ elementów w kolejce.

Dziedziczenie
Queue<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu przedstawia kilka metod Queue<T> klasy ogólnej. Przykładowy kod tworzy kolejkę ciągów z domyślną pojemnością i używa Enqueue metody do kolejkowania pięciu ciągów. Elementy kolejki są wyliczane, co nie zmienia stanu kolejki. Metoda Dequeue służy do dequeue pierwszego ciągu. Metoda Peek służy do przyjrzenia się następnemu elementowi w kolejce, a następnie Dequeue metoda jest używana do jego dequeue.

Metoda ToArray służy do tworzenia tablicy i kopiowania do niej elementów kolejki, a następnie tablica jest przekazywana do Queue<T> konstruktora, który przyjmuje IEnumerable<T>, tworząc kopię kolejki. Zostaną wyświetlone elementy kopii.

Tablica dwukrotnie rozmiar kolejki jest tworzony, a CopyTo metoda służy do kopiowania elementów tablicy rozpoczynających się w środku tablicy. Konstruktor Queue<T> jest ponownie używany do tworzenia drugiej kopii kolejki zawierającej trzy elementy null na początku.

Metoda Contains służy do pokazywania, że ciąg "cztery" znajduje się w pierwszej kopii kolejki, po której Clear metoda czyści kopię, a Count właściwość pokazuje, że kolejka jest pusta.

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Queue<string> numbers = new Queue<string>();
        numbers.Enqueue("one");
        numbers.Enqueue("two");
        numbers.Enqueue("three");
        numbers.Enqueue("four");
        numbers.Enqueue("five");

        // A queue can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nDequeuing '{0}'", numbers.Dequeue());
        Console.WriteLine("Peek at next item to dequeue: {0}",
            numbers.Peek());
        Console.WriteLine("Dequeuing '{0}'", numbers.Dequeue());

        // Create a copy of the queue, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Queue<string> queueCopy = new Queue<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in queueCopy )
        {
            Console.WriteLine(number);
        }

        // Create an array twice the size of the queue and copy the
        // elements of the queue, starting at the middle of the
        // array.
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);

        // Create a second queue, using the constructor that accepts an
        // IEnumerable(Of T).
        Queue<string> queueCopy2 = new Queue<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in queueCopy2 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nqueueCopy.Contains(\"four\") = {0}",
            queueCopy.Contains("four"));

        Console.WriteLine("\nqueueCopy.Clear()");
        queueCopy.Clear();
        Console.WriteLine("\nqueueCopy.Count = {0}", queueCopy.Count);
    }
}

/* This code example produces the following output:

one
two
three
four
five

Dequeuing 'one'
Peek at next item to dequeue: two
Dequeuing 'two'

Contents of the first copy:
three
four
five

Contents of the second copy, with duplicates and nulls:



three
four
five

queueCopy.Contains("four") = True

queueCopy.Clear()

queueCopy.Count = 0
 */
open System
open System.Collections.Generic

let numbers = Queue()
numbers.Enqueue "one"
numbers.Enqueue "two"
numbers.Enqueue "three"
numbers.Enqueue "four"
numbers.Enqueue "five"

// A queue can be enumerated without disturbing its contents.
for number in numbers do
    printfn $"{number}"

printfn $"\nDequeuing '{numbers.Dequeue()}'"
printfn $"Peek at next item to dequeue: {numbers.Peek()}"
printfn $"Dequeuing '{numbers.Dequeue()}'"

// Create a copy of the queue, using the ToArray method and the
// constructor that accepts an IEnumerable<T>.
let queueCopy = numbers.ToArray() |> Queue

printfn $"\nContents of the first copy:"
for number in queueCopy do
    printfn $"{number}"

// Create an array twice the size of the queue and copy the
// elements of the queue, starting at the middle of the
// array.
let array2 = numbers.Count * 2 |> Array.zeroCreate
numbers.CopyTo(array2, numbers.Count)

// Create a second queue, using the constructor that accepts an
// IEnumerable(Of T).
let queueCopy2 = Queue array2

printfn $"\nContents of the second copy, with duplicates and nulls:"
for number in queueCopy2 do
    printfn $"{number}"
printfn $"""\nqueueCopy.Contains "four" = {queueCopy.Contains "four"}"""

printfn $"\nqueueCopy.Clear()"
queueCopy.Clear()
printfn $"queueCopy.Count = {queueCopy.Count}"

// This code example produces the following output:
//       one
//       two
//       three
//       four
//       five
//       
//       Dequeuing 'one'
//       Peek at next item to dequeue: two
//       Dequeuing 'two'
//       
//       Contents of the first copy:
//       three
//       four
//       five
//       
//       Contents of the second copy, with duplicates and nulls:
//       
//       
//       
//       three
//       four
//       five
//       
//       queueCopy.Contains "four" = True
//       
//       queueCopy.Clear()
//       
//       queueCopy.Count = 0
Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Queue(Of String)
        numbers.Enqueue("one")
        numbers.Enqueue("two")
        numbers.Enqueue("three")
        numbers.Enqueue("four")
        numbers.Enqueue("five")

        ' A queue can be enumerated without disturbing its contents.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Dequeuing '{0}'", numbers.Dequeue())
        Console.WriteLine("Peek at next item to dequeue: {0}", _
            numbers.Peek())    
        Console.WriteLine("Dequeuing '{0}'", numbers.Dequeue())

        ' Create a copy of the queue, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T).
        Dim queueCopy As New Queue(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In queueCopy
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the queue, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the queue, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second queue, using the constructor that accepts an
        ' IEnumerable(Of T).
        Dim queueCopy2 As New Queue(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and nulls:")
        For Each number As String In queueCopy2
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "queueCopy.Contains(""four"") = {0}", _
            queueCopy.Contains("four"))

        Console.WriteLine(vbLf & "queueCopy.Clear()")
        queueCopy.Clear()
        Console.WriteLine(vbLf & "queueCopy.Count = {0}", _
            queueCopy.Count)
    End Sub
End Module

' This code example produces the following output:
'
'one
'two
'three
'four
'five
'
'Dequeuing 'one'
'Peek at next item to dequeue: two
'
'Dequeuing 'two'
'
'Contents of the copy:
'three
'four
'five
'
'Contents of the second copy, with duplicates and nulls:
'
'
'
'three
'four
'five
'
'queueCopy.Contains("four") = True
'
'queueCopy.Clear()
'
'queueCopy.Count = 0

Uwagi

Ta klasa implementuje kolejkę ogólną jako tablicę cykliczną. Obiekty przechowywane w obiekcie Queue<T> są wstawiane na jednym końcu i usuwane z drugiego. Kolejki i stosy są przydatne, gdy potrzebujesz tymczasowego magazynu w celu uzyskania informacji; oznacza to, że po pobraniu jego wartości można odrzucić element. Użyj polecenia Queue<T> , jeśli musisz uzyskać dostęp do informacji w tej samej kolejności, która jest przechowywana w kolekcji. Użyj polecenia Stack<T> , jeśli chcesz uzyskać dostęp do informacji w odwrotnej kolejności. Użyj ConcurrentQueue<T> polecenia lub ConcurrentStack<T> jeśli musisz uzyskać dostęp do kolekcji z wielu wątków jednocześnie.

Trzy główne operacje można wykonać na elemecie Queue<T> i jego elementach:

  • Enqueue dodaje element na końcu elementu Queue<T>.

  • Dequeue usuwa najstarszy element od początku Queue<T>elementu .

  • Peek podgląd zwraca najstarszy element, który znajduje się na początku Queue<T> elementu, ale nie usuwa go z elementu Queue<T>.

Pojemność elementu Queue<T> to liczba elementów, które Queue<T> może pomieścić. W miarę dodawania elementów do obiektu Queue<T>pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez przydział tablicy wewnętrznej. Pojemność można zmniejszyć przez wywołanie metody TrimExcess.

Queue<T>null akceptuje jako prawidłową wartość dla typów referencyjnych i zezwala na zduplikowane elementy.

Konstruktory

Queue<T>()

Inicjuje Queue<T> nowe wystąpienie klasy, która jest pusta i ma domyślną pojemność początkową.

Queue<T>(IEnumerable<T>)

Inicjuje Queue<T> nowe wystąpienie klasy zawierające elementy skopiowane z określonej kolekcji i ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów.

Queue<T>(Int32)

Inicjuje Queue<T> nowe wystąpienie klasy, która jest pusta i ma określoną pojemność początkową.

Właściwości

Capacity

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

Count

Pobiera liczbę elementów zawartych w słowniku Queue<T>.

Metody

Clear()

Usuwa wszystkie obiekty z obiektu Queue<T>.

Contains(T)

Określa, czy element znajduje się w elemecie Queue<T>.

CopyTo(T[], Int32)

Kopiuje Queue<T> elementy do istniejącego jednowymiarowego Array, zaczynając od określonego indeksu tablicy.

Dequeue()

Usuwa i zwraca obiekt na początku obiektu Queue<T>.

Enqueue(T)

Dodaje obiekt na końcu obiektu Queue<T>.

EnsureCapacity(Int32)

Gwarantuje, że pojemność tej kolejki jest co najmniej określona capacity. Jeśli bieżąca pojemność jest mniejsza niż capacity, zostanie zwiększona do co najmniej określonej capacitywartości .

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający, który iteruje za pomocą elementu Queue<T>.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Peek()

Zwraca obiekt na początku Queue<T> obiektu bez jego usunięcia.

ToArray()

Kopiuje Queue<T> elementy do nowej tablicy.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
TrimExcess()

Ustawia pojemność na rzeczywistą liczbę elementów w elemencie Queue<T>, jeśli ta liczba jest mniejsza niż 90 procent bieżącej pojemności.

TrimExcess(Int32)

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

TryDequeue(T)

Usuwa obiekt na początku Queue<T>obiektu i kopiuje go do parametru result .

TryPeek(T)

Zwraca wartość wskazującą, czy na początku Queue<T>obiektu znajduje się obiekt , a jeśli jest obecny, kopiuje go do parametru result . Obiekt nie jest usuwany z obiektu Queue<T>.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection elementu do obiektu Array, zaczynając od określonego Array indeksu.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do elementu ICollection jest synchronizowany (bezpieczny wątek).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu ICollection.

IEnumerable.GetEnumerator()

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

IEnumerable<T>.GetEnumerator()

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

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>)

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

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>)

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

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>)

Reprezentuje kolekcję obiektów typu first-in-first-out (FIFO).

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

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 rodzajową na ogólną IEnumerable<T>IQueryable<T>wartość .

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy główne każdego węzła w kolekcji źródłowej.

Ancestors<T>(IEnumerable<T>, XName)

Zwraca filtrowaną kolekcję elementów, które zawierają elementy główne 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 przefiltrowaną kolekcję elementów zawierających 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 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ą 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

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) elementy członkowskie tego typu są bezpieczne wątkami. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.

Obiekt Queue<T> może obsługiwać wiele czytników jednocześnie, o ile kolekcja nie jest modyfikowana. Mimo to wyliczanie kolekcji nie jest wewnętrznie procedurą bezpieczną wątkowo. Aby zapoznać się z kolejką bezpieczną wątkowo, zobacz ConcurrentQueue<T>.