Dictionary<TKey,TValue> Třída

Definice

Představuje kolekci klíčů a hodnot.

generic <typename TKey, typename TValue>
public ref class Dictionary : 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 Dictionary : 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::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
generic <typename TKey, typename TValue>
public ref class Dictionary : 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::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
public class Dictionary<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 Dictionary<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.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Dictionary<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.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Dictionary<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.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Dictionary<'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
type Dictionary<'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
    interface IDeserializationCallback
    interface ISerializable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Dictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Dictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Dictionary<'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>>
    interface ISerializable
    interface IDeserializationCallback
type Dictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Dictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ISerializable
    interface IDeserializationCallback
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class Dictionary(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 Dictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDeserializationCallback, IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue), ISerializable
Public Class Dictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDeserializationCallback, IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), ISerializable

Parametry typu

TKey

Typ klíčů ve slovníku.

TValue

Typ hodnot ve slovníku.

Dědičnost
Dictionary<TKey,TValue>
Odvozené
Atributy
Implementuje

Příklady

Následující příklad kódu vytvoří prázdné Dictionary<TKey,TValue> řetězce s řetězcovými klíči a použije metodu Add k přidání některých prvků. Příklad ukazuje, že Add metoda vyvolá ArgumentException při pokusu o přidání duplicitního klíče.

Příklad používá Item[] vlastnost (indexer v jazyce C#) k načtení hodnot, což demonstruje, že je vyvolána, KeyNotFoundException když požadovaný klíč není k dispozici, a ukazuje, že hodnota přidružená ke klíči lze nahradit.

Příklad ukazuje, jak použít metodu TryGetValue jako efektivnější způsob načtení hodnot, pokud program často musí vyzkoušet klíčové hodnoty, které nejsou ve slovníku, a ukazuje, jak pomocí ContainsKey metody otestovat, zda klíč existuje před voláním Add metody.

Příklad ukazuje, jak vytvořit výčet klíčů a hodnot ve slovníku a jak vytvořit výčet klíčů a hodnot samostatně pomocí Keys vlastnosti a Values vlastnosti.

Nakonec příklad ukazuje metodu Remove .

using namespace System;
using namespace System::Collections::Generic;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new dictionary of strings, with string keys.
        //
        Dictionary<String^, String^>^ openWith =
            gcnew Dictionary<String^, String^>();

        // Add some elements to the dictionary. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the dictionary.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch (ArgumentException^)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you
        // can omit its name when accessing elements.
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console::WriteLine("For key = \"tif\", value = {0}.",
                openWith["tif"]);
        }
        catch (KeyNotFoundException^)
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient
        // way to retrieve values.
        String^ value = "";
        if (openWith->TryGetValue("tif", value))
        {
            Console::WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}",
                openWith["ht"]);
        }

        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( KeyValuePair<String^, String^> kvp in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}",
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        Dictionary<String^, String^>::ValueCollection^ valueColl =
            openWith->Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console::WriteLine();
        for each( String^ s in valueColl )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        Dictionary<String^, String^>::KeyCollection^ keyColl =
            openWith->Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for dictionary keys.
        Console::WriteLine();
        for each( String^ s in keyColl )
        {
            Console::WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

int main()
{
    Example::Main();
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
 */
// Create a new dictionary of strings, with string keys.
//
Dictionary<string, string> openWith =
    new Dictionary<string, string>();

// Add some elements to the dictionary. There are no
// duplicate keys, but some of the values are duplicates.
openWith.Add("txt", "notepad.exe");
openWith.Add("bmp", "paint.exe");
openWith.Add("dib", "paint.exe");
openWith.Add("rtf", "wordpad.exe");

// The Add method throws an exception if the new key is
// already in the dictionary.
try
{
    openWith.Add("txt", "winword.exe");
}
catch (ArgumentException)
{
    Console.WriteLine("An element with Key = \"txt\" already exists.");
}

// The Item property is another name for the indexer, so you
// can omit its name when accessing elements.
Console.WriteLine("For key = \"rtf\", value = {0}.",
    openWith["rtf"]);

// The indexer can be used to change the value associated
// with a key.
openWith["rtf"] = "winword.exe";
Console.WriteLine("For key = \"rtf\", value = {0}.",
    openWith["rtf"]);

// If a key does not exist, setting the indexer for that key
// adds a new key/value pair.
openWith["doc"] = "winword.exe";

// The indexer throws an exception if the requested key is
// not in the dictionary.
try
{
    Console.WriteLine("For key = \"tif\", value = {0}.",
        openWith["tif"]);
}
catch (KeyNotFoundException)
{
    Console.WriteLine("Key = \"tif\" is not found.");
}

// When a program often has to try keys that turn out not to
// be in the dictionary, TryGetValue can be a more efficient
// way to retrieve values.
string value = "";
if (openWith.TryGetValue("tif", out value))
{
    Console.WriteLine("For key = \"tif\", value = {0}.", value);
}
else
{
    Console.WriteLine("Key = \"tif\" is not found.");
}

// ContainsKey can be used to test keys before inserting
// them.
if (!openWith.ContainsKey("ht"))
{
    openWith.Add("ht", "hypertrm.exe");
    Console.WriteLine("Value added for key = \"ht\": {0}",
        openWith["ht"]);
}

// When you use foreach to enumerate dictionary elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine();
foreach( KeyValuePair<string, string> kvp in openWith )
{
    Console.WriteLine("Key = {0}, Value = {1}",
        kvp.Key, kvp.Value);
}

// To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl =
    openWith.Values;

// The elements of the ValueCollection are strongly typed
// with the type that was specified for dictionary values.
Console.WriteLine();
foreach( string s in valueColl )
{
    Console.WriteLine("Value = {0}", s);
}

// To get the keys alone, use the Keys property.
Dictionary<string, string>.KeyCollection keyColl =
    openWith.Keys;

// The elements of the KeyCollection are strongly typed
// with the type that was specified for dictionary keys.
Console.WriteLine();
foreach( string s in keyColl )
{
    Console.WriteLine("Key = {0}", s);
}

// Use the Remove method to remove a key/value pair.
Console.WriteLine("\nRemove(\"doc\")");
openWith.Remove("doc");

if (!openWith.ContainsKey("doc"))
{
    Console.WriteLine("Key \"doc\" is not found.");
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
*/
Imports System.Collections.Generic

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new dictionary of strings, with string keys.
        '
        Dim openWith As New Dictionary(Of String, String)
        
        ' Add some elements to the dictionary. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")
        
        ' The Add method throws an exception if the new key is 
        ' already in the dictionary.
        Try
            openWith.Add("txt", "winword.exe")
        Catch 
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' If a key does not exist, setting the default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' The default Item property throws an exception if the requested
        ' key is not in the dictionary.
        Try
            Console.WriteLine("For key = ""tif"", value = {0}.", _
                openWith("tif"))
        Catch 
            Console.WriteLine("Key = ""tif"" is not found.")
        End Try

        ' When a program often has to try keys that turn out not to
        ' be in the dictionary, TryGetValue can be a more efficient 
        ' way to retrieve values.
        Dim value As String = ""
        If openWith.TryGetValue("tif", value) Then
            Console.WriteLine("For key = ""tif"", value = {0}.", value)
        Else
            Console.WriteLine("Key = ""tif"" is not found.")
        End If

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate dictionary elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each kvp As KeyValuePair(Of String, String) In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                kvp.Key, kvp.Value)
        Next kvp

        ' To get the values alone, use the Values property.
        Dim valueColl As _
            Dictionary(Of String, String).ValueCollection = _
            openWith.Values
        
        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for dictionary values.
        Console.WriteLine()
        For Each s As String In  valueColl
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl As _
            Dictionary(Of String, String).KeyCollection = _
            openWith.Keys
        
        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for dictionary keys.
        Console.WriteLine()
        For Each s As String In  keyColl
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")
        
        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Class

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Key = "tif" is not found.
'Key = "tif" is not found.
'Value added for key = "ht": hypertrm.exe
'
'Key = txt, Value = notepad.exe
'Key = bmp, Value = paint.exe
'Key = dib, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'Key = ht, Value = hypertrm.exe
'
'Value = notepad.exe
'Value = paint.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'Value = hypertrm.exe
'
'Key = txt
'Key = bmp
'Key = dib
'Key = rtf
'Key = doc
'Key = ht
'
'Remove("doc")
'Key "doc" is not found.
'

Poznámky

Obecná Dictionary<TKey,TValue> třída poskytuje mapování ze sady klíčů na sadu hodnot. Každý doplněk slovníku se skládá z hodnoty a jeho přidruženého klíče. Načtení hodnoty pomocí jeho klíče je velmi rychlé, blízko O(1), protože Dictionary<TKey,TValue> třída je implementována jako hashovací tabulka.

Poznámka

Rychlost načítání závisí na kvalitě algoritmu hash typu zadaného pro TKey.

Pokud se objekt používá jako klíč v objektu Dictionary<TKey,TValue>, nesmí se žádným způsobem změnit, který má vliv na hodnotu hash. Každý klíč v klíči Dictionary<TKey,TValue> musí být jedinečný podle porovnávače rovnosti slovníku. Klíč nemůže být null, ale hodnota může být, pokud je jeho typem TValue odkaz.

Dictionary<TKey,TValue> vyžaduje implementaci rovnosti, aby bylo možné určit, zda jsou klíče stejné. Implementaci IEqualityComparer<T> obecného rozhraní můžete zadat pomocí konstruktoru, který přijímá comparer parametr. Pokud neurčujete implementaci, použije se výchozí obecný porovnávač EqualityComparer<T>.Default rovnosti. Pokud typ TKey implementuje System.IEquatable<T> obecné rozhraní, použije výchozí porovnávač rovnosti tuto implementaci.

Poznámka

Můžete například použít porovnávače řetězců nerozlišující malá a velká písmena, StringComparer které poskytuje třída k vytvoření slovníků s řetězcovými klíči bez rozlišování velkých a malých písmen.

Kapacita jednotky Dictionary<TKey,TValue> je počet prvků, které Dictionary<TKey,TValue> může obsahovat. Při přidání prvků do objektu Dictionary<TKey,TValue>se kapacita automaticky zvýší podle potřeby přidělením interního pole.

pouze .NET Framework: U velmi velkých Dictionary<TKey,TValue> objektů můžete zvýšit maximální kapacitu na 2 miliardy prvků v 64bitovém systému nastavením enabled atributu elementu <gcAllowVeryLargeObjects> konfigurace do true prostředí za běhu.

Pro účely výčtu se každá položka ve slovníku považuje za KeyValuePair<TKey,TValue> strukturu představující hodnotu a její klíč. Pořadí, ve kterém jsou položky vráceny, není definováno.

Příkaz foreach jazyka C# (for eachv jazyce C++, For Each v Visual Basic) vrátí objekt typu prvků v kolekci. Vzhledem k tomu, že Dictionary<TKey,TValue> je kolekce klíčů a hodnot, typ prvku není typem klíče nebo typem hodnoty. Místo toho je KeyValuePair<TKey,TValue> typ prvku typu klíče a typ hodnoty. Například:

for each(KeyValuePair<String^, String^> kvp in myDictionary)
{
    Console::WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
foreach( KeyValuePair<string, string> kvp in myDictionary )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
For Each kvp As KeyValuePair(Of String, String) In myDictionary
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value)
Next kvp

Příkaz foreach je obálka kolem enumerátoru, která umožňuje jen čtení z kolekce, nikoli zápis do něj.

Poznámka

Vzhledem k tomu, že klíče lze dědit a jejich chování změnit, není možné jejich absolutní jedinečnost zaručit porovnáním pomocí Equals metody.

Konstruktory

Dictionary<TKey,TValue>()

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která je prázdná, má výchozí počáteční kapacitu a používá výchozí porovnání rovnosti pro typ klíče.

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

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která obsahuje prvky zkopírované ze zadaného IDictionary<TKey,TValue> pole a používá výchozí porovnávač rovnosti pro typ klíče.

Dictionary<TKey,TValue>(IDictionary<TKey,TValue>, IEqualityComparer<TKey>)

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

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

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která obsahuje prvky zkopírované ze zadané IEnumerable<T>.

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

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

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

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která je prázdná, má výchozí počáteční kapacitu a používá zadanou IEqualityComparer<T>.

Dictionary<TKey,TValue>(Int32)

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která je prázdná, má zadanou počáteční kapacitu a používá výchozí porovnání rovnosti pro typ klíče.

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

Inicializuje novou instanci Dictionary<TKey,TValue> třídy, která je prázdná, má zadanou počáteční kapacitu a používá zadanou IEqualityComparer<T>.

Dictionary<TKey,TValue>(SerializationInfo, StreamingContext)

Inicializuje novou instanci třídy Dictionary<TKey,TValue> se serializovanými daty.

Vlastnosti

Comparer

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

Count

Získá počet párů klíč/hodnota obsažených v souboru Dictionary<TKey,TValue>.

Item[TKey]

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

Keys

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

Values

Získá kolekci obsahující hodnoty v souboru Dictionary<TKey,TValue>.

Metody

Add(TKey, TValue)

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

Clear()

Odebere ze souboru Dictionary<TKey,TValue>všechny klíče a hodnoty .

ContainsKey(TKey)

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

ContainsValue(TValue)

Určuje, zda Dictionary<TKey,TValue> obsahuje konkrétní hodnotu.

EnsureCapacity(Int32)

Zajistí, aby slovník mohl obsahovat až zadaný počet položek bez dalšího rozšíření úložiště backingu.

Equals(Object)

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

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

Vrátí enumerátor, který iteruje přes Dictionary<TKey,TValue>.

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementuje ISerializable rozhraní a vrátí data potřebná k serializaci Dictionary<TKey,TValue> instance.

GetType()

Type Získá aktuální instanci.

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

Vytvoří použádnou kopii aktuálního souboru Object.

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

Implementuje ISerializable rozhraní a vyvolá událost deserializace po dokončení deserializace.

Remove(TKey)

Odebere hodnotu se zadaným klíčem ze Dictionary<TKey,TValue>souboru .

Remove(TKey, TValue)

Odebere hodnotu se zadaným klíčem ze Dictionary<TKey,TValue>souboru a zkopíruje prvek do parametru value .

ToString()

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

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

Nastaví kapacitu tohoto slovníku na to, co by bylo, kdyby byla původně inicializována se všemi jeho položkami.

TrimExcess(Int32)

Nastaví kapacitu tohoto slovníku tak, aby zadržovala zadaný počet položek bez dalšího rozšíření úložiště backingu.

TryAdd(TKey, TValue)

Pokusí se přidat zadaný klíč a hodnotu do slovníku.

TryGetValue(TKey, TValue)

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

Explicitní implementace rozhraní

ICollection.CopyTo(Array, Int32)

Zkopíruje prvky pole ICollection<T> počínaje zadaným indexem pole.

ICollection.IsSynchronized

Získá hodnotu, která označuje, zda je přístup k synchronizaci ICollection (vlákno bezpečné).

ICollection.SyncRoot

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

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

Přidá zadanou hodnotu do ICollection<T> zadaného klíče.

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

Určuje, zda ICollection<T> obsahuje určitý klíč a hodnotu.

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

Zkopíruje prvky ICollection<T> pole typu KeyValuePair<TKey,TValue>počínaje zadaným indexem pole.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Získá hodnotu, která označuje, zda slovník je jen pro čtení.

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

Odebere klíč a hodnotu ze slovníku.

IDictionary.Add(Object, Object)

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

IDictionary.Contains(Object)

Určuje, zda IDictionary obsahuje prvek se zadaným klíčem.

IDictionary.GetEnumerator()

IDictionaryEnumerator Vrátí hodnotu pro IDictionary.

IDictionary.IsFixedSize

Získá hodnotu, která označuje, zda IDictionary má pevnou velikost.

IDictionary.IsReadOnly

Získá hodnotu, která označuje, zda IDictionary je jen pro čtení.

IDictionary.Item[Object]

Získá nebo nastaví hodnotu se zadaným klíčem.

IDictionary.Keys

ICollection Získá obsahující klíče .IDictionary

IDictionary.Remove(Object)

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

IDictionary.Values

ICollection Získá obsahující hodnoty v souboru IDictionary.

IDictionary<TKey,TValue>.Keys

ICollection<T> Získá obsahující klíče .IDictionary<TKey,TValue>

IDictionary<TKey,TValue>.Values

ICollection<T> Získá obsahující hodnoty v souboru IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Získá enumerátor, který provádí iteraci v kolekci.

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()

Získá enumerátor, který provádí iteraci v kolekci.

IReadOnlyDictionary<TKey,TValue>.Keys

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

IReadOnlyDictionary<TKey,TValue>.Values

Získá kolekci obsahující hodnoty .IReadOnlyDictionary<TKey,TValue>

Metody rozšíření

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

Vrátí obálku jen ReadOnlyDictionary<TKey,TValue> pro čtení pro aktuální slovník.

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

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

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

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

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

Pokusí se odebrat hodnotu zadanou key ze zadané hodnoty dictionary.

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

Pokusí se přidat zadané key a value do dictionarysouboru .

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

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

Vytvoří výčet a transformaci sekvence a vytvoří neměnný slovník jeho 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 transformaci sekvence a vytvoří neměnný slovník jeho obsahu pomocí zadaných klíčových a hodnotových porovnávačů.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

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

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

Vytvoří výčet sekvence, vytvoří neměnnou sadu hodnot hash jejího obsahu a použije zadaný porovnávač rovnosti pro typ sady.

ToImmutableList<TSource>(IEnumerable<TSource>)

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

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

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu.

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

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu pomocí zadaného porovnávače klíčů.

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

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu pomocí zadaných porovnávacích klíčů a hodnot.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

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

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

Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jeho obsahu a použije zadaný porovnávací modul.

CopyToDataTable<T>(IEnumerable<T>)

DataTable Vrátí hodnotu, která obsahuje kopie DataRow objektů, vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

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

Zkopíruje DataRow objekty do zadaného DataTableobjektu , vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

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

Zkopíruje DataRow objekty do zadaného DataTableobjektu , vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

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

Použije funkci akumulátoru na sekvenci.

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

Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota akumulátoru se používá jako počáteční hodnota akumulátoru.

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

Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se používá jako počáteční hodnota akumulátoru a zadaná funkce slouží k výběru výsledné hodnoty.

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

Určuje, zda všechny prvky sekvence splňují podmínku.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje všechny prvky.

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

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

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

Připojí hodnotu na konec sekvence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup zadaný jako IEnumerable<T>.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Cast<TResult>(IEnumerable)

Přetypuje prvky zadaného IEnumerable typu.

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

Rozdělí prvky sekvence na bloky 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ý prvek pomocí výchozího porovnávače rovnosti.

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

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

Count<TSource>(IEnumerable<TSource>)

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

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

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci splňuje podmínku.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

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

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

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

Distinct<TSource>(IEnumerable<TSource>)

Vrátí jedinečné prvky ze sekvence pomocí výchozího porovnávače rovnosti k porovnání hodnot.

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

Vrátí odlišné prvky ze sekvence pomocí zadané IEqualityComparer<T> hodnoty k porovnání hodnot.

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

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

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

Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů a pomocí zadaného porovnávacího nástroje k porovnání klíčů.

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

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

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

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

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

Vrátí prvek v zadaném indexu v posloupnosti nebo výchozí hodnotě, pokud je index mimo rozsah.

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

Vrátí prvek v zadaném indexu v posloupnosti nebo výchozí hodnotě, pokud je index mimo rozsah.

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

Vytvoří množinu dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.

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

Vytvoří množinu dvou sekvencí pomocí zadaného IEqualityComparer<T> k porovnání hodnot.

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

Vytvoří množinu dvou sekvencí podle zadané funkce selektoru klíče.

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

Vytvoří množinu dvou sekvencí podle zadané funkce selektoru klíče.

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 se nenajde žádný takový prvek.

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

Vrátí první prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud se nenajde žádný takový prvek.

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íčů a zadává prvky pro každou skupinu pomocí zadané funkce.

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

Seskupí prvky sekvence podle funkce selektoru klíčů. Klíče se porovnávají pomocí porovnávače a prvky jednotlivých skupin se projektují 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íčů 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íčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíče se porovnávají pomocí zadaného porovnávače.

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íčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Prvky každé skupiny se projektují 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íčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíčové hodnoty se porovnávají pomocí zadaného porovnávače a prvky každé skupiny se projektují 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 seskupuje výsledky. Výchozí porovnávač 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ě klíčové rovnosti a seskupuje výsledky. Zadaný IEqualityComparer<T> klíč se používá k porovnání klíčů.

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

Vytvoří průnik dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.

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

Vytvoří průsečík dvou sekvencí pomocí zadaného IEqualityComparer<T> porovnání hodnot.

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

Vytvoří množinou průsečík dvou sekvencí podle zadané funkce selektoru klíče.

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

Vytvoří množinou průsečík dvou sekvencí podle zadané funkce selektoru klíče.

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

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> se používá 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 se nenajde žádný takový prvek.

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

Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud se nenajde žádný takový prvek.

LongCount<TSource>(IEnumerable<TSource>)

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

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

Vrátí hodnotu 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 pro každý prvek sekvence a vrátí maximální Decimal hodnotu.

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

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

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

Vyvolá transformační funkci na každém prvku sekvence a vrátí maximální Int32 hodnotu.

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

Vyvolá transformační funkci na každém prvku 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í hodnotu nullable Decimal .

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

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

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

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

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

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

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

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

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

Vyvolá transformační funkci na každém prvku 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 pro každý prvek sekvence a vrátí minimální Decimal hodnotu.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vyvolá transformační funkci pro každý prvek 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 IEnumerable založené na zadaném typu.

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

Seřadí prvky sekvence vzestupně 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>)

Invertuje pořadí prvků v posloupnosti.

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

Prodá jednotlivé prvky sekvence do nového formuláře.

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

Začlení každý prvek sekvence do nového formuláře zahrnutím indexu prvku.

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

Prodá jednotlivé prvky sekvence na IEnumerable<T> sekvenci a zploštějí výsledné sekvence do jedné sekvence.

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

Prodá jednotlivé prvky sekvence na sekvenci IEnumerable<T>a zploštějí výsledné sekvence do jedné sekvence. Index každého zdrojového elementu se používá v projektované podobě tohoto prvku.

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

Zarovná jednotlivé prvky sekvence na IEnumerable<T>sekvenci , zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků u každého prvku v něm.

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

Zarovná jednotlivé prvky sekvence na IEnumerable<T>sekvenci , zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků u každého prvku v něm. Index každého zdrojového prvku se používá v přechodném projektované podobě tohoto prvku.

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

Určuje, zda jsou dvě sekvence stejné porovnáním prvků pomocí výchozího porovnávače rovnosti pro jejich typ.

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

Určuje, zda jsou dvě sekvence stejné porovnáním jejich prvků pomocí zadaného 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 neexistuje žádný takový prvek; 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 posloupnosti a potom vrátí zbývající prvky.

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

Vrátí novou výčtovou kolekci, která obsahuje prvky z source posledního count prvku zdrojové kolekce vynechána.

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

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

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

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

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

Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vrátí zadaný počet souvislých prvků od začátku sekvence.

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

Vrátí zadanou oblast souvislých prvků ze sekvence.

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

Vrátí novou výčtovou kolekci, která obsahuje poslední count prvky z source.

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

Vrátí prvky z posloupnosti, pokud je zadaná podmínka pravdivá.

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

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

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z objektu IEnumerable<T>.

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

Dictionary<TKey,TValue> Vytvoří ze zadané funkce selektoru klíčů z IEnumerable<T> závislosti na zadané funkci selektoru klíčů.

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

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

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

Dictionary<TKey,TValue> Vytvoří ze zadaného selektoru IEnumerable<T> klíče a funkce selektoru prvků.

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

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

ToHashSet<TSource>(IEnumerable<TSource>)

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

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

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

ToList<TSource>(IEnumerable<TSource>)

List<T> Vytvoří z objektu IEnumerable<T>.

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

Lookup<TKey,TElement> Vytvoří z funkce IEnumerable<T> selektoru klíčů podle zadané funkce selektoru klíčů.

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

Lookup<TKey,TElement> Vytvoří ze zadané funkce selektoru klíčů a porovnávače klíčů ze IEnumerable<T> zadané funkce.

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

Lookup<TKey,TElement> Vytvoří ze zadaného selektoru IEnumerable<T> klíče a funkce selektoru prvků.

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

Lookup<TKey,TElement> Vytvoří ze IEnumerable<T> zadané funkce selektoru klíče, porovnávače a funkce selektoru prvků.

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ří sjednocovací sadu dvou sekvencí pomocí výchozího porovnávače rovnosti.

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

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

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

Vytvoří sjednocování dvou sekvencí podle zadané funkce selektoru klíče.

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

Vytvoří sjednocování dvou sekvencí podle zadané funkce selektoru klíče.

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í a vytvoří sekvenci výsledků.

AsParallel(IEnumerable)

Umožňuje paralelizaci dotazu.

AsParallel<TSource>(IEnumerable<TSource>)

Umožňuje paralelizaci dotazu.

AsQueryable(IEnumerable)

Převede na IEnumerable 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ředky každého uzlu ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci prvků, která obsahuje nadřazené prvky každého uzlu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

DescendantNodes<T>(IEnumerable<T>)

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

Descendants<T>(IEnumerable<T>)

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

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

Vrátí filtrovanou kolekci prvků, která obsahuje následné prvky každého prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků 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 prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, která obsahuje 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 každý uzel ve zdrojové kolekci z nadřazeného uzlu.

Platí pro

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

A Dictionary<TKey,TValue> může současně podporovat více čtenářů, pokud se kolekce nezmění. I tak je výčet kolekce vnitřně ne procedurou bezpečnou pro vlákno. Ve výjimečných případech, kdy výčet bojuje s přístupem k zápisu, musí být kolekce uzamčena během celého výčtu. Chcete-li více vláknům umožnit přístup ke kolekci pro čtení a zápis, musíte implementovat svou vlastní synchronizaci.

Informace o alternativách bezpečných pro přístup z více vláken najdete v ConcurrentDictionary<TKey,TValue> třídě nebo ImmutableDictionary<TKey,TValue> třídě.

Veřejné statické členy tohoto typu (Sharedv Visual Basic) jsou bezpečné pro vlákno.

Viz také