Queue<T> Třída

Definice

Představuje kolekci objektů first-in.Represents a first-in, first-out collection of objects.

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
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Queue<'T> = class
    interface seq<'T>
    interface ICollection
    interface IReadOnlyCollection<'T>
    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

Určuje typ prvků ve frontě.Specifies the type of elements in the queue.

Dědičnost
Queue<T>
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje několik metod Queue<T> Obecné třídy.The following code example demonstrates several methods of the Queue<T> generic class. Příklad kódu vytvoří frontu řetězců s výchozí kapacitou a pomocí Enqueue metody zařadí do fronty pět řetězců.The code example creates a queue of strings with default capacity and uses the Enqueue method to queue five strings. Pro prvky fronty se zobrazí výčty, které nezmění stav fronty.The elements of the queue are enumerated, which does not change the state of the queue. DequeueMetoda se používá k odstranění fronty prvního řetězce.The Dequeue method is used to dequeue the first string. PeekMetoda se používá k zobrazení další položky ve frontě a následně Dequeue k jejímu vyřazení z této metody.The Peek method is used to look at the next item in the queue, and then the Dequeue method is used to dequeue it.

ToArrayMetoda slouží k vytvoření pole a zkopírování prvků fronty do něj, pak je předána do Queue<T> konstruktoru, který přijímá IEnumerable<T> , vytvoření kopie fronty.The ToArray method is used to create an array and copy the queue elements to it, then the array is passed to the Queue<T> constructor that takes IEnumerable<T>, creating a copy of the queue. Zobrazí se prvky kopie.The elements of the copy are displayed.

Pole dvojnásobku velikosti fronty je vytvořeno a CopyTo metoda se používá ke zkopírování prvků pole začínajících uprostřed pole.An array twice the size of the queue is created, and the CopyTo method is used to copy the array elements beginning at the middle of the array. Queue<T>Konstruktor se znovu používá k vytvoření druhé kopie fronty obsahující tři elementy s hodnotou null na začátku.The Queue<T> constructor is used again to create a second copy of the queue containing three null elements at the beginning.

ContainsMetoda se používá k ukázání, že řetězec "4" je v první kopii fronty, po které Clear Metoda vymaže kopii a Count vlastnost ukazuje, že je fronta prázdná.The Contains method is used to show that the string "four" is in the first copy of the queue, after which the Clear method clears the copy and the Count property shows that the queue is empty.

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

Poznámky

Tato třída implementuje obecnou frontu jako kruhové pole.This class implements a generic queue as a circular array. Objekty uložené ve a Queue<T> jsou vloženy na jeden konec a odebrány z druhé.Objects stored in a Queue<T> are inserted at one end and removed from the other. Fronty a zásobníky jsou užitečné v případě, že pro informace potřebujete dočasné úložiště. To znamená, že pokud budete chtít po načtení jeho hodnoty zrušit element.Queues and stacks are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Použijte Queue<T> v případě, že potřebujete získat přístup k informacím ve stejném pořadí, v jakém jsou uloženy v kolekci.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Použijte Stack<T> v případě, že potřebujete získat přístup k informacím v opačném pořadí.Use Stack<T> if you need to access the information in reverse order. Použijte ConcurrentQueue<T> nebo, ConcurrentStack<T> Pokud potřebujete přistupovat ke kolekci z více vláken současně.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

Tři hlavní operace lze provádět u Queue<T> a jejích elementů:Three main operations can be performed on a Queue<T> and its elements:

Kapacita Queue<T> je počet prvků, které Queue<T> mohou být uloženy.The capacity of a Queue<T> is the number of elements the Queue<T> can hold. Když jsou prvky přidány do Queue<T> , kapacita se automaticky zvýší, jak je požadováno přerozdělením interního pole.As elements are added to a Queue<T>, the capacity is automatically increased as required by reallocating the internal array. Kapacitu lze snížit voláním TrimExcess .The capacity can be decreased by calling TrimExcess.

Queue<T> přijímá null jako platnou hodnotu pro typy odkazů a povoluje duplicitní prvky.Queue<T> accepts null as a valid value for reference types and allows duplicate elements.

Konstruktory

Queue<T>()

Inicializuje novou instanci Queue<T> třídy, která je prázdná a má výchozí počáteční kapacitu.Initializes a new instance of the Queue<T> class that is empty and has the default initial capacity.

Queue<T>(IEnumerable<T>)

Inicializuje novou instanci Queue<T> třídy, která obsahuje prvky zkopírované ze zadané kolekce a má dostatečnou kapacitu pro přizpůsobení počtu kopírovaných prvků.Initializes a new instance of the Queue<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

Queue<T>(Int32)

Inicializuje novou instanci Queue<T> třídy, která je prázdná a má zadanou počáteční kapacitu.Initializes a new instance of the Queue<T> class that is empty and has the specified initial capacity.

Vlastnosti

Count

Získá počet elementů obsažených v objektu Queue<T>.Gets the number of elements contained in the Queue<T>.

Metody

Clear()

Odebere všechny objekty z Queue<T> .Removes all objects from the Queue<T>.

Contains(T)

Určuje, zda je element v Queue<T> .Determines whether an element is in the Queue<T>.

CopyTo(T[], Int32)

Zkopíruje Queue<T> prvky na existující jednorozměrné Array , počínaje zadaným indexem pole.Copies the Queue<T> elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue()

Odebere a vrátí objekt na začátku Queue<T> .Removes and returns the object at the beginning of the Queue<T>.

Enqueue(T)

Přidá objekt na konec Queue<T> .Adds an object to the end of the Queue<T>.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetEnumerator()

Vrátí enumerátor, který projde Queue<T> .Returns an enumerator that iterates through the Queue<T>.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
Peek()

Vrátí objekt na začátku objektu Queue<T> bez jeho odebrání.Returns the object at the beginning of the Queue<T> without removing it.

ToArray()

Zkopíruje Queue<T> prvky do nového pole.Copies the Queue<T> elements to a new array.

ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)
TrimExcess()

Nastaví kapacitu na skutečný počet prvků v Queue<T> , pokud je toto číslo menší než 90% aktuální kapacity.Sets the capacity to the actual number of elements in the Queue<T>, if that number is less than 90 percent of current capacity.

TryDequeue(T)

Odstraní objekt na začátku Queue<T> a zkopíruje jej do result parametru.Removes the object at the beginning of the Queue<T>, and copies it to the result parameter.

TryPeek(T)

Vrátí hodnotu, která označuje, zda je objekt na začátku Queue<T> , a pokud je přítomný, zkopíruje jej do result parametru.Returns a value that indicates whether there is an object at the beginning of the Queue<T>, and if one is present, copies it to the result parameter. Objekt není odebrán z Queue<T> .The object is not removed from the Queue<T>.

Explicitní implementace rozhraní

ICollection.CopyTo(Array, Int32)

Zkopíruje prvky ICollection do a Array počínaje konkrétním Array indexem.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Načte hodnotu, která označuje, jestli se má synchronizovat přístup k aplikaci (bezpečné pro přístup z ICollection více vláken).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Získává objekt, který lze použít k synchronizaci přístupu k ICollection .Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Vrací enumerátor procházející kolekci.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Vrací enumerátor procházející kolekci.Returns an enumerator that iterates through a collection.

Metody rozšíření

ToImmutableArray<TSource>(IEnumerable<TSource>)

Vytvoří neměnné pole ze zadané kolekce.Creates an immutable array from the specified collection.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Sestaví neproměnlivý slovník z existující kolekce elementů a použije funkci transformace na zdrojové klíče.Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří neproměnlivý slovník založený na určité transformaci sekvence.Constructs an immutable dictionary based on some transformation of a sequence.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu pomocí zadaného klíčového porovnávání.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu pomocí zadaných porovnatelností klíčová a hodnotová.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnitelnou sadu hash jejího obsahu.Enumerates a sequence and produces an immutable hash set of its contents.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří výčet sekvencí, vytvoří neměnitelnou sadu hodnot hash jejího obsahu a použije pro typ sady zadanou porovnávací metodu.Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.

ToImmutableList<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnný seznam jeho obsahu.Enumerates a sequence and produces an immutable list of its contents.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý seřazený slovník jeho obsahu.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jeho obsahu pomocí zadaného klíčového porovnávání.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý seřazený slovník jeho obsahu pomocí zadaných porovnávače klíčová a hodnotová.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neproměnlivou seřazenou sadu jejího obsahu.Enumerates a sequence and produces an immutable sorted set of its contents.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Vytvoří výčet sekvencí, vytvoří neproměnlivou seřazenou sadu jejího obsahu a použije zadanou porovnávací metodu.Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

CopyToDataTable<T>(IEnumerable<T>)

Vrátí DataTable , který obsahuje kopie DataRow objektů, a to tak, že předané vstupní IEnumerable<T> objekt, kde je obecný parametr T DataRow .Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru.The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru a zadaná funkce slouží k výběru hodnoty výsledku.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda všechny prvky sekvence splní podmínku.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje nějaké prvky.Determines whether a sequence contains any elements.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda kterýkoli prvek sekvence splňuje podmínku.Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IEnumerable<TSource>, TSource)

Připojí hodnotu na konec sekvence.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup zadaný jako IEnumerable<T> .Returns the input typed as IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá průměr sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá průměr sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá průměr sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá průměr sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá průměr sekvence hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá průměr sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Zřetězí dvě sekvence.Concatenates two sequences.

Contains<TSource>(IEnumerable<TSource>, TSource)

Určuje, zda sekvence obsahuje zadaný element pomocí výchozí porovnávače rovnosti.Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Určuje, zda sekvence obsahuje zadaný element pomocí zadaného prvku IEqualityComparer<T> .Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Vrátí počet prvků v sekvenci.Returns the number of elements in a sequence.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci vyhovuje podmínce.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Vrátí prvky zadané sekvence nebo zadanou hodnotu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Vrátí odlišné prvky z sekvence pomocí výchozí porovnávací metody pro porovnání hodnot.Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vrátí odlišné prvky z sekvence pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v sekvenci.Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří množinový rozdíl dvou sekvencí pomocí výchozí porovnávací metody pro porovnání hodnot.Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří množinový rozdíl dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence.Returns the first element of a sequence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek v sekvenci, která splňuje zadanou podmínku.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče.Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a porovná klíče s použitím zadané porovnávací metody.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a projekty prvků pro každou skupinu pomocí zadané funkce.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Seskupí prvky pořadí podle funkce selektoru klíče.Groups the elements of a sequence according to a key selector function. Klíče jsou porovnány pomocí porovnávacího prvku a jednotlivé prvky skupiny jsou probíhají pomocí zadané funkce.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Klíče jsou porovnány pomocí zadané porovnávací metody.The keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Prvky každé skupiny jsou probíhají pomocí zadané funkce.The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Hodnoty klíčů jsou porovnány pomocí zadané porovnávací metody a prvky každé skupiny jsou probíhají pomocí zadané funkce.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

Koreluje prvky dvou sekvencí na základě rovnosti klíčů a skupin výsledků.Correlates the elements of two sequences based on equality of keys and groups the results. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupí výsledky.Correlates the elements of two sequences based on key equality and groups the results. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří průniky sady dvou sekvencí pomocí výchozí porovnávače rovnosti pro porovnání hodnot.Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří průnik dvou sekvencí sady pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Koreluje prvky dvou sekvencí založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence.Returns the last element of a sequence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, který splňuje zadanou podmínku.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the last element of a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>)

Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci.Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí hodnotu Int64 reprezentující, kolik prvků v sekvenci splní podmínku.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.Returns the maximum value in a generic sequence.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Single value.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí maximální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.Returns the minimum value in a generic sequence.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Single value.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí minimální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence ve vzestupném pořadí podle klíče.Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence ve vzestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence v sestupném pořadí podle klíče.Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence v sestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Přidá hodnotu na začátek sekvence.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Obrátí pořadí prvků v sekvenci.Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Projektuje každý prvek sekvence do nového formuláře.Projects each element of a sequence into a new form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Projektuje každý prvek sekvence do nového formuláře zahrnutím indexu elementu.Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Projekty jednotlivé prvky sekvence do IEnumerable<T> a sloučí výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projekty jsou jednotlivé prvky sekvence IEnumerable<T> a jsou shrnuty ve výsledných sekvencích do jedné sekvence.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. Index každého zdrojového elementu se používá v projektované podobě daného prvku.The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. Index jednotlivých zdrojových elementů se používá v mezilehlém projektovém formuláři tohoto prvku.The index of each source element is used in the intermediate projected form of that element.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Určuje, zda jsou dvě sekvence stejné, porovnáním prvků s použitím výchozí porovnávače rovnosti pro svůj typ.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Určuje, zda se dvě sekvence rovnají porovnáním jejich prvků pomocí zadaného parametru IEqualityComparer<T> .Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence nebo výchozí hodnotu, pokud je sekvence prázdná. Tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, nebo výchozí hodnotu, pokud žádný takový prvek neexistuje. Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínky.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IEnumerable<TSource>, Int32)

Obchází zadaný počet prvků v sekvenci a vrátí zbývající prvky.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou vyčíslitelné kolekci, která obsahuje prvky z source s posledními count prvky zdrojové kolekce vynechány.Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá součet sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá součet sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá součet sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá součet sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá součet sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Take<TSource>(IEnumerable<TSource>, Int32)

Vrátí zadaný počet souvislých prvků od začátku sekvence.Returns a specified number of contiguous elements from the start of a sequence.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou vyčíslitelné kolekci, která obsahuje poslední count prvky z source .Returns a new enumerable collection that contains the last count elements from source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z IEnumerable<T> .Creates an array from a IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří Dictionary<TKey,TValue> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to specified key selector and element selector functions.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče, porovnávání a funkci selektor elementu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function, a comparer, and an element selector function.

ToHashSet<TSource>(IEnumerable<TSource>)

Vytvoří HashSet<T> z IEnumerable<T> .Creates a HashSet<T> from an IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří HashSet<T> z s IEnumerable<T> pomocí comparer k porovnání klíčů.Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Vytvoří List<T> z IEnumerable<T> .Creates a List<T> from an IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to specified key selector and element selector functions.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče, porovnávací funkce a funkci selektor elementu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function, a comparer and an element selector function.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří sjednocení dvou sekvencí pomocí výchozí porovnávače rovnosti.Produces the set union of two sequences by using the default equality comparer.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří sjednocení ze dvou sekvencí pomocí zadaného typu IEqualityComparer<T> .Produces the set union of two sequences by using a specified IEqualityComparer<T>.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate. Index každého elementu se používá v Logic funkce predikátu.Each element's index is used in the logic of the predicate function.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Vytvoří sekvenci řazených kolekcí členů s prvky ze dvou zadaných sekvencí.Produces a sequence of tuples with elements from the two specified sequences.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Použije zadanou funkci na odpovídající prvky dvou sekvencí a vytvoří tak sekvenci výsledků.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable .Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Převede obecný IEnumerable<T> na obecný IQueryable<T> .Converts a generic IEnumerable<T> to a generic IQueryable<T>.

Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of the child elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci.Returns a filtered collection of the child elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.Removes every node in the source collection from its parent node.

Platí pro

Bezpečný přístup z více vláken

Veřejné statické ( Shared v Visual Basic) členy tohoto typu jsou bezpečné pro přístup z více vláken.Public static (Shared in Visual Basic) members of this type are thread safe. U členů instancí není zaručena bezpečnost pro přístup z více vláken.Any instance members are not guaranteed to be thread safe.

Queue<T>Může podporovat více čtenářů souběžně, pokud se kolekce nemění.A Queue<T> can support multiple readers concurrently, as long as the collection is not modified. I když je výčet prostřednictvím kolekce vnitřně nebezpečný pro přístup z více vláken.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Pro frontu bezpečnou pro přístup z více vláken naleznete v tématu ConcurrentQueue<T> .For a thread-safe queue, see ConcurrentQueue<T>.