ConcurrentDictionary<TKey,TValue> Třída

Definice

Představuje kolekci párů klíč/hodnota, které jsou bezpečné pro přístup z více vláken, ke kterým lze přistupovat více vlákny současně.

generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary
generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::IDictionary
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.IDictionary
type ConcurrentDictionary<'Key, 'Value> = class
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection
    interface IDictionary
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary
    interface ICollection
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)
Public Class ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue))

Parametry typu

TKey

Typ klíčů ve slovníku.

TValue

Typ hodnot ve slovníku.

Dědičnost
ConcurrentDictionary<TKey,TValue>
Atributy
Implementuje

Příklady

Následující příklad ukazuje, jak vytvořit ConcurrentDictionary<TKey,TValue> objekt.


class CD_Ctor
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
        //      ConcurrentDictionary<TKey, TValue>[TKey]
        static void Main()
        {
            // We know how many items we want to insert into the ConcurrentDictionary.
            // So set the initial capacity to some prime number above that, to ensure that
            // the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;

            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises.
            // For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;
            int concurrencyLevel = numProcs * 2;

            // Construct the dictionary with the desired concurrencyLevel and initialCapacity
            ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity);

            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

            Console.WriteLine("The square of 23 is {0} (should be {1})", cd[23], 23 * 23);
        }
}
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Class CD_Ctor
    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
    ' ConcurrentDictionary<TKey, TValue>[TKey]
    Shared Sub Main()
        ' We know how many items we want to insert into the ConcurrentDictionary.
        ' So set the initial capacity to some prime number above that, to ensure that
        ' the ConcurrentDictionary does not need to be resized while initializing it.
        Dim NUMITEMS As Integer = 64
        Dim initialCapacity As Integer = 101

        ' The higher the concurrencyLevel, the higher the theoretical number of operations
        ' that could be performed concurrently on the ConcurrentDictionary. However, global
        ' operations like resizing the dictionary take longer as the concurrencyLevel rises. 
        ' For the purposes of this example, we'll compromise at numCores * 2.
        Dim numProcs As Integer = Environment.ProcessorCount
        Dim concurrencyLevel As Integer = numProcs * 2

        ' Construct the dictionary with the desired concurrencyLevel and initialCapacity
        Dim cd As New ConcurrentDictionary(Of Integer, Integer)(concurrencyLevel, initialCapacity)

        ' Initialize the dictionary
        For i As Integer = 0 To NUMITEMS - 1
            cd(i) = i * i
        Next

        Console.WriteLine("The square of 23 is {0} (should be {1})", cd(23), 23 * 23)
    End Sub
End Class

Poznámky

U velmi velkých ConcurrentDictionary<TKey,TValue> objektů můžete zvýšit maximální velikost pole na 2 gigabajty (GB) v 64 systému nastavením <gcAllowVeryLargeObjects> konfiguračního elementu na true v prostředí Runtime.

Poznámka

ConcurrentDictionary<TKey,TValue>implementuje IReadOnlyCollection<T> rozhraní a IReadOnlyDictionary<TKey,TValue> počínaje .NET Framework 4,6; v předchozích verzích .NET Framework ConcurrentDictionary<TKey,TValue> třída neimplementovala tato rozhraní.

Podobně jako System.Collections.Generic.Dictionary<TKey,TValue> Třída ConcurrentDictionary<TKey,TValue> implementuje IDictionary<TKey,TValue> rozhraní. Kromě toho ConcurrentDictionary<TKey,TValue> poskytuje několik metod pro přidání nebo aktualizaci párů klíč/hodnota ve slovníku, jak je popsáno v následující tabulce.

Akce Použít tuto metodu Poznámky k použití
Přidejte nový klíč do slovníku, pokud ještě neexistuje ve slovníku. TryAdd Tato metoda přidá zadaný pár klíč/hodnota, pokud klíč aktuálně ve slovníku neexistuje. Metoda vrátí true nebo false v závislosti na tom, zda byla nová dvojice přidána.
Aktualizuje hodnotu existujícího klíče ve slovníku, pokud má tento klíč určitou hodnotu. TryUpdate Tato metoda kontroluje, zda má klíč zadanou hodnotu a v případě, že je, aktualizuje klíč novou hodnotou. Je podobný CompareExchange metodě, s tím rozdílem, že se používá pro prvky slovníku.
Uložte dvojici klíč/hodnota ve slovníku bezpodmínečně a přepište hodnotu klíče, který už existuje. Metoda setter indexeru: dictionary[key] = newValue
Přidejte do slovníku dvojici klíč/hodnota, nebo pokud klíč už existuje, aktualizujte hodnotu klíče na základě existující hodnoty klíče. AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

-nebo-

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)
AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>) akceptuje klíč a dva delegáty. Použije první delegáta, pokud klíč ve slovníku neexistuje. akceptuje klíč a vrátí hodnotu, která se má pro klíč přidat. Pokud klíč existuje, používá druhý delegáta. akceptuje klíč a jeho aktuální hodnotu a vrátí novou hodnotu, kterou je třeba pro klíč nastavit.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>) akceptuje klíč, hodnotu, kterou chcete přidat, a delegáta aktualizace. To je stejné jako předchozí přetížení, s tím rozdílem, že nepoužívá delegáta k přidání klíče.
Získá hodnotu klíče ve slovníku, přidá hodnotu do slovníku a vrátí ji, pokud klíč neexistuje. GetOrAdd(TKey, TValue)

-nebo-

GetOrAdd(TKey, Func<TKey,TValue>)
Tato přetížení poskytují opožděnou inicializaci dvojice klíč/hodnota ve slovníku a tato hodnota se přidává pouze v případě, že tam není.

GetOrAdd(TKey, TValue) Pokud klíč neexistuje, převezme se hodnota, která se má přidat.

GetOrAdd(TKey, Func<TKey,TValue>) převezme delegáta, který bude generovat hodnotu, pokud klíč neexistuje.

Všechny tyto operace jsou atomické a jsou bezpečné pro přístup z více vláken s ohledem na všechny ostatní operace ConcurrentDictionary<TKey,TValue> třídy. Jedinou výjimkou jsou metody, které přijímají delegáta, to znamená AddOrUpdate a GetOrAdd . Pro úpravy a operace zápisu do slovníku používá nástroj ConcurrentDictionary<TKey,TValue> k zajištění bezpečnosti vlákna jemně odstupňované zamykání. (Operace čtení ve slovníku se provádí způsobem bez zámků.) Nicméně Delegáti pro tyto metody jsou voláni mimo zámky, aby se předešlo problémům, které mohou nastat při provádění neznámého kódu v rámci zámku. Proto kód, který provede tyto delegáty, není předmětem atomické operace.

Konstruktory

ConcurrentDictionary<TKey,TValue>()

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která je prázdná, má výchozí úroveň souběžnosti, má výchozí počáteční kapacitu a používá výchozí porovnávací třídu pro typ klíče.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která obsahuje prvky zkopírované ze zadaného IEnumerable<T> , má výchozí úroveň souběžnosti, má výchozí počáteční kapacitu a používá výchozí porovnávací klíč pro typ klíče.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která obsahuje elementy zkopírované ze zadaného, má výchozí IEnumerable počáteční kapacitu a používá zadanou hodnotu IEqualityComparer<T> .

ConcurrentDictionary<TKey,TValue>(IEqualityComparer<TKey>)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která je prázdná, má výchozí úroveň souběžnosti a kapacitu a používá zadanou hodnotu IEqualityComparer<T> .

ConcurrentDictionary<TKey,TValue>(Int32, IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která obsahuje prvky zkopírované ze zadaného IEnumerable a používá zadanou IEqualityComparer<T> .

ConcurrentDictionary<TKey,TValue>(Int32, Int32)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která je prázdná, má zadanou úroveň souběžnosti a kapacitu a používá výchozí porovnávací metodu pro typ klíče.

ConcurrentDictionary<TKey,TValue>(Int32, Int32, IEqualityComparer<TKey>)

Inicializuje novou instanci ConcurrentDictionary<TKey,TValue> třídy, která je prázdná, má zadanou úroveň souběžnosti, má zadanou počáteční kapacitu a používá zadanou hodnotu IEqualityComparer<T> .

Vlastnosti

Comparer

Získá IEqualityComparer<T> , který slouží k určení rovnosti klíčů pro slovník.

Count

Získá počet párů klíč/hodnota, které jsou obsaženy v ConcurrentDictionary<TKey,TValue> .

IsEmpty

Získá hodnotu, která určuje, zda ConcurrentDictionary<TKey,TValue> je prázdná.

Item[TKey]

Získá nebo nastaví hodnotu přidruženou k zadanému klíči.

Keys

Získá kolekci obsahující klíče v Dictionary<TKey,TValue> .

Values

Získá kolekci, která obsahuje hodnoty v Dictionary<TKey,TValue> .

Metody

AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

Pomocí zadaných funkcí přidá dvojici klíč/hodnota do, ConcurrentDictionary<TKey,TValue> Pokud klíč ještě neexistuje, nebo pokud chcete aktualizovat dvojici klíč/hodnota v případě, že ConcurrentDictionary<TKey,TValue> klíč už existuje.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)

Přidá dvojici klíč/hodnota do, ConcurrentDictionary<TKey,TValue> Pokud klíč ještě neexistuje, nebo aktualizuje dvojici klíč/hodnota v rámci ConcurrentDictionary<TKey,TValue> pomocí zadané funkce, pokud klíč už existuje.

AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)

Pomocí zadaných funkcí a argumentu přidá dvojici klíč/hodnota do, ConcurrentDictionary<TKey,TValue> Pokud klíč ještě neexistuje, nebo pokud chcete aktualizovat dvojici klíč/hodnota v případě, že ConcurrentDictionary<TKey,TValue> klíč už existuje.

Clear()

Odebere všechny klíče a hodnoty z ConcurrentDictionary<TKey,TValue> .

ContainsKey(TKey)

Určuje, zda ConcurrentDictionary<TKey,TValue> obsahuje zadaný klíč.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

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

Vrátí enumerátor, který projde ConcurrentDictionary<TKey,TValue> .

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetOrAdd(TKey, Func<TKey,TValue>)

Přidá dvojici klíč/hodnota k pomocí ConcurrentDictionary<TKey,TValue> zadané funkce, pokud klíč ještě neexistuje. Vrátí novou hodnotu nebo existující hodnotu, pokud klíč existuje.

GetOrAdd(TKey, TValue)

Přidá pár klíč/hodnota do ConcurrentDictionary<TKey,TValue> , pokud klíč ještě neexistuje. Vrátí novou hodnotu nebo existující hodnotu, pokud klíč existuje.

GetOrAdd<TArg>(TKey, Func<TKey,TArg,TValue>, TArg)

Přidá pár klíč/hodnota do objektu pomocí zadané funkce a argumentu, pokud klíč ještě neexistuje, nebo vrátí existující hodnotu, pokud ConcurrentDictionary<TKey,TValue> klíč existuje.

GetType()

Získá Type aktuální instanci.

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

Vytvoří kopii aktuálního seznamu Object .

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

Zkopíruje páry klíč-hodnota uložená v poli ConcurrentDictionary<TKey,TValue> do nového pole.

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)
TryAdd(TKey, TValue)

Pokusí se přidat zadaný klíč a hodnotu do ConcurrentDictionary<TKey,TValue> .

TryGetValue(TKey, TValue)

Pokusí se získat hodnotu přidruženou k zadanému klíči z ConcurrentDictionary<TKey,TValue> .

TryRemove(KeyValuePair<TKey,TValue>)

Odebere klíč a hodnotu ze slovníku.

TryRemove(TKey, TValue)

Pokusí se odebrat a vrátit hodnotu, která má zadaný klíč z ConcurrentDictionary<TKey,TValue> .

TryUpdate(TKey, TValue, TValue)

Aktualizuje hodnotu přidruženou key k na, newValue Pokud je stávající hodnota key shodná s hodnotou comparisonValue .

Explicitní implementace rozhraní

ICollection.CopyTo(Array, Int32)

Zkopíruje prvky do ICollection pole počínaje zadaným indexem pole.

ICollection.IsSynchronized

Získá hodnotu, která určuje, jestli je ICollection přístup k synchronní s SyncRoot.

ICollection.SyncRoot

Získá objekt, který lze použít k synchronizaci přístupu k ICollection . Tato vlastnost se nepodporuje.

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)

Přidá položku do kolekce.

ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)

Získá, ICollection<T> zda obsahuje prvek se zadaným klíčem.

ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)

Zkopíruje prvky do ICollection pole počínaje zadaným indexem pole.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Získá hodnotu, která určuje, zda ICollection je jen pro čtení.

ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)

Odebere zadaný pár klíč/hodnota z kolekce.

IDictionary.Add(Object, Object)

Přidá zadaný klíč a hodnotu do slovníku.

IDictionary.Contains(Object)

Získá hodnotu, která IDictionary<TKey,TValue> označuje, že obsahuje prvek se zadaným klíčem.

IDictionary.GetEnumerator()

Poskytuje IDictionaryEnumerator pro IDictionary<TKey,TValue> .

IDictionary.IsFixedSize

Získá hodnotu, která určuje, zda IDictionary<TKey,TValue> má pevnou velikost.

IDictionary.IsReadOnly

Získá hodnotu, která určuje, zda IDictionary<TKey,TValue> je jen pro čtení.

IDictionary.Item[Object]

Získá nebo nastaví hodnotu přidruženou k zadanému klíči.

IDictionary.Keys

Získá ICollection , který obsahuje klíče IDictionary<TKey,TValue> .

IDictionary.Remove(Object)

Odebere prvek se zadaným klíčem z IDictionary .

IDictionary.Values

Získá ICollection objekt , který obsahuje hodnoty v IDictionary objektu .

IDictionary<TKey,TValue>.Add(TKey, TValue)

Přidá zadaný klíč a hodnotu do IDictionary<TKey,TValue> .

IDictionary<TKey,TValue>.Remove(TKey)

Odebere prvek se zadaným klíčem z IDictionary<TKey,TValue> .

IEnumerable.GetEnumerator()

Vrátí enumerátor, který prochází přes ConcurrentDictionary<TKey,TValue> .

IReadOnlyDictionary<TKey,TValue>.Keys

Získá kolekci obsahující klíče v Dictionary<TKey,TValue> .

IReadOnlyDictionary<TKey,TValue>.Values

Získá kolekci, která obsahuje hodnoty v Dictionary<TKey,TValue> .

Metody rozšíření

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)

Pokusí se získat hodnotu přidruženou k zadanému key v dictionary .

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)

Pokusí se získat hodnotu přidruženou k zadanému klíči v dictionary .

Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Pokusí se odebrat hodnotu se zadaným key z dictionary .

TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Pokusí se přidat zadané key a value k dictionary .

ToImmutableArray<TSource>(IEnumerable<TSource>)

Vytvoří neměnné pole ze zadané kolekce.

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

Vytvoří neměnný slovník z existující kolekce prvků a použije transformační funkci na zdrojové klíče.

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

Vytvoří neměnný slovník na základě určité transformace sekvence.

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

Vytvoří výčet a transformaci sekvence a vytvoří neměnný slovník jejího obsahu.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaného porovnávače klíčů.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaných porovnávačů klíčů a hodnot.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnitelnou sadu hash jejího obsahu.

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.

ToImmutableList<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnný seznam jeho obsahu.

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.

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

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

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvence a vytvoří neměnnou seřazenou sadu jejího obsahu.

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

Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jejího obsahu a použije zadanou porovnávač.

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 .

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 .

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 .

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

Aplikuje funkci Akumulovaná v rámci sekvence.

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

Aplikuje funkci Akumulovaná v rámci sekvence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru.

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

Aplikuje funkci Akumulovaná v rámci sekvence. 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.

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

Určuje, zda všechny prvky sekvence splní podmínku.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje nějaké prvky.

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

Určuje, zda kterýkoli prvek sekvence splňuje podmínku.

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

Připojí hodnotu na konec sekvence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup, který je typovaný jako IEnumerable<T> .

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

Vypočítá průměr posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Decimal prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Double prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Int32 prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Int64 prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Decimal prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Double prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Int32 prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Int64 prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Single prvek vstupní sekvence.

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

Vypočítá průměr posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Single prvek vstupní sekvence.

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.

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

Rozdělí prvky sekvence do bloků velikosti nejvíce size .

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

Zřetězí dvě sekvence.

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

Určuje, zda sekvence obsahuje zadaný element pomocí výchozí porovnávače rovnosti.

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

Určuje, zda sekvence obsahuje zadaný element pomocí zadaného prvku IEqualityComparer<T> .

Count<TSource>(IEnumerable<TSource>)

Vrátí počet prvků v sekvenci.

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

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci vyhovuje podmínce.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v kolekci singleton, pokud je sekvence prázdná.

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

Vrátí prvky zadané sekvence nebo zadanou hodnotu v kolekci singleton, pokud je sekvence prázdná.

Distinct<TSource>(IEnumerable<TSource>)

Vrátí odlišné prvky z sekvence pomocí výchozí porovnávací metody pro porovnání hodnot.

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

Vrátí odlišné prvky z sekvence pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.

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

Vrátí odlišné prvky z sekvence podle zadané funkce selektoru klíče.

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

Vrátí odlišné prvky z sekvence podle zadané funkce selektoru klíče a použitím zadané porovnávací metody k porovnání klíčů.

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

Vrátí prvek v zadaném indexu v sekvenci.

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

Vrátí prvek na zadaném indexu v sekvenci.

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

Vrátí prvek na zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.

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

Vrátí prvek na zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.

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

Vytvoří rozdíl sady dvou sekvencí pomocí výchozí porovnávače rovnosti pro porovnání hodnot.

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

Vytvoří rozdíl sady dvou sekvencí pomocí zadaných hodnot IEqualityComparer<T> pro porovnání hodnot.

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

Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.

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

Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.

First<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence.

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

Vrátí první prvek v sekvenci, která splňuje zadanou podmínku.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

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

Vrátí první prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

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

Vrátí první prvek sekvence, který splňuje podmínku, nebo výchozí hodnotu, pokud takový prvek není nalezen.

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

Vrátí první prvek sekvence, který splňuje podmínku, nebo zadanou výchozí hodnotu, pokud takový prvek není nalezen.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíčů.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a porovná klíče pomocí zadaného porovnávače.

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.

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

Seskupí prvky pořadí podle funkce selektoru klíče. Klíče jsou porovnány pomocí porovnávacího prvku a jednotlivé prvky skupiny jsou probíhají pomocí zadané funkce.

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.

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. Klíče jsou porovnány pomocí zadané porovnávací metody.

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. Prvky každé skupiny jsou probíhají pomocí zadané funkce.

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. Hodnoty klíčů jsou porovnány pomocí zadané porovnávací metody a prvky každé skupiny jsou probíhají pomocí zadané funkce.

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ů. Výchozí porovnávání rovnosti se používá k porovnání klíčů.

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. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.

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

Vytvoří průniky sady dvou sekvencí pomocí výchozí porovnávače rovnosti pro porovnání hodnot.

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

Vytvoří průnik dvou sekvencí sady pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.

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

Vytvoří průnik sady dvou sekvencí podle zadané funkce selektoru klíčů.

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

Vytvoří průnik sady dvou sekvencí podle zadané funkce selektoru klíčů.

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

Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. K porovnání klíčů se používá výchozí porovnávací metoda rovnosti.

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í na základě odpovídajících klíčů. Zadaná IEqualityComparer<T> hodnota slouží k porovnání klíčů.

Last<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence.

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

Vrátí poslední prvek sekvence, která splňuje zadanou podmínku.

LastOrDefault<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

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

Vrátí poslední prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

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

Vrátí poslední prvek sekvence, která splňuje podmínku nebo výchozí hodnotu, pokud takový prvek není nalezen.

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

Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud takový prvek není nalezen.

LongCount<TSource>(IEnumerable<TSource>)

Vrátí Int64 , který představuje celkový počet prvků v sekvenci.

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

Vrátí , Int64 který představuje, kolik prvků v sekvenci splňuje podmínku.

Max<TSource>(IEnumerable<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.

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

Vrátí maximální hodnotu v obecné sekvenci.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí maximální Decimal hodnotu.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí maximální Double hodnotu.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu.

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.

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.

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.

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.

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.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu.

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

Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí maximální výslednou hodnotu.

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

Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.

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

Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.

Min<TSource>(IEnumerable<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.

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

Vrátí minimální hodnotu v obecné sekvenci.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí minimální Decimal hodnotu.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí minimální Double hodnotu.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí minimální Int32 hodnotu.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí minimální Int64 hodnotu.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu Decimal nullable.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu Double nullable.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu Int32 nullable.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu Int64 nullable.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu Single nullable.

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

Vyvolá transformační funkci u každého prvku sekvence a vrátí minimální Single hodnotu.

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

Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí minimální výslednou hodnotu.

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

Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.

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

Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.

OfType<TResult>(IEnumerable)

Filtruje prvky objektu IEnumerable na základě zadaného typu.

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

Seřadí prvky sekvence ve vzestupném pořadí podle klíče.

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

Seřadí prvky sekvence ve vzestupném pořadí pomocí zadaného porovnávače.

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

Seřadí prvky sekvence v sestupném pořadí podle klíče.

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

Seřadí prvky sekvence v sestupném pořadí pomocí zadaného porovnávače.

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

Přidá hodnotu na začátek sekvence.

Reverse<TSource>(IEnumerable<TSource>)

Obrátí pořadí prvků v sekvenci.

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

Projektuje každý prvek sekvence do nového formuláře.

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

Projektuje každý prvek sekvence do nového formuláře zahrnutím indexu elementu.

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

Projekty jednotlivé prvky sekvence do IEnumerable<T> a sloučí výsledné sekvence do jedné sekvence.

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. Index každého zdrojového elementu se používá v projektované podobě daného prvku.

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.

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. Index jednotlivých zdrojových elementů se používá v mezilehlém projektovém formuláři tohoto prvku.

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.

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

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.

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.

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.

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

Vrátí jediný prvek sekvence nebo zadanou výchozí hodnotu, pokud je sekvence prázdná. Tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.

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

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, nebo výchozí hodnotu, pokud takový prvek neexistuje. Tato metoda vyvolá výjimku, pokud podmínku splňuje více než jeden prvek.

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

Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, nebo zadanou výchozí hodnotu, pokud takový prvek neexistuje. Tato metoda vyvolá výjimku, pokud podmínku splňuje více než jeden prvek.

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

Obchází zadaný počet prvků v sekvenci a pak vrátí zbývající prvky.

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

Vrátí novou vyčíslitelnou kolekci, která obsahuje prvky z s posledními prvky zdrojové kolekce source count vynechány.

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

Obchází prvky v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky.

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

Obchází prvky v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky. Index prvku se používá v logice predikátové funkce.

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.

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

Vypočítá součet posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Double prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Int32 prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Int64 prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Decimal prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Double prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Int32 prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Int64 prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null, které jsou získány vyvoláním transformační funkce pro každý Single prvek vstupní sekvence.

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

Vypočítá součet posloupnosti hodnot, které jsou získány vyvoláním transformační funkce pro každý Single prvek vstupní sekvence.

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

Vrátí zadaný počet souvislé prvky od začátku sekvence.

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

Vrátí zadaný rozsah souvislé prvky ze sekvence.

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

Vrátí novou vyčíslitelnou kolekci, která obsahuje poslední count prvky z source .

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

Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá.

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

Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá. Index prvku se používá v logice predikátové funkce.

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z IEnumerable<T> objektu .

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

Vytvoří z Dictionary<TKey,TValue> objektu podle zadané funkce IEnumerable<T> selektoru klíčů.

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

Vytvoří z Dictionary<TKey,TValue> podle zadané funkce selektoru klíčů a IEnumerable<T> porovnávače klíčů.

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

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.

ToHashSet<TSource>(IEnumerable<TSource>)

Vytvoří HashSet<T> z IEnumerable<T> .

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

Vytvoří HashSet<T> z s IEnumerable<T> pomocí comparer k porovnání klíčů.

ToList<TSource>(IEnumerable<TSource>)

Vytvoří List<T> z 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.

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.

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

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.

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

Pokusí se určit počet prvků v sekvenci bez vynucení výčtu.

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

Vytvoří sjednocenou sadu dvou sekvencí pomocí výchozí porovnávače rovnosti.

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

Vytvoří sjednocenou sadu dvou sekvencí pomocí zadaného IEqualityComparer<T> .

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

Vytvoří sjednocenou sadu dvou sekvencí podle zadané funkce selektoru klíčů.

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

Vytvoří sjednocenou sadu dvou sekvencí podle zadané funkce selektoru klíčů.

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

Filtruje posloupnost hodnot na základě predikátu.

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

Filtruje posloupnost hodnot na základě predikátu. Index každého prvku se používá v logice predikátové funkce.

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

Vytvoří sekvenci řazených členů s prvky ze dvou zadaných sekvencí.

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

Vytvoří sekvenci řazených členů s prvky ze tří zadaných sekvencí.

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

Použije zadanou funkci na odpovídající prvky dvou sekvencí, které vytvářejí posloupnost výsledků.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.

AsParallel<TSource>(IEnumerable<TSource>)

Povoluje paralelní zpracování dotazu.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable .

AsQueryable<TElement>(IEnumerable<TElement>)

Převede obecný IEnumerable<T> na obecný IQueryable<T> .

Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .

DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci následných uzlů každého dokumentu a elementu ve zdrojové kolekci.

Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.

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

Vrátí filtrované kolekce elementů, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze XName prvky, které mají shodu.

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených elementů každého prvku a dokumentu ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.

Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.

Remove<T>(IEnumerable<T>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.

Platí pro

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

Všechny veřejné a chráněné členy jsou bezpečné pro přístup z více vláken ConcurrentDictionary<TKey,TValue> a lze je používat souběžně z více vláken. Nicméně členové, kteří jsou přístupem prostřednictvím jednoho z rozhraní, a, ConcurrentDictionary<TKey,TValue> včetně rozšiřujících metod, nejsou zaručeny bezpečný přístup z více vláken a mohou být muset být synchronizováni volajícím.

Viz také