Dictionary<TKey,TValue> Klasa

Definicja

Reprezentuje kolekcję kluczy i wartości.Represents a collection of keys and values.

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
[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 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)), IDeserializationCallback, IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue), ISerializable

Parametry typu

TKey

Typ kluczy w słowniku.The type of the keys in the dictionary.

TValue

Typ wartości w słowniku.The type of the values in the dictionary.

Dziedziczenie
Dictionary<TKey,TValue>
Pochodne
Atrybuty
Implementuje

Przykłady

Uwaga

Przykłady języka C#, w tym artykule są uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.The C# examples in this article run in the Try.NET inline code runner and playground. Wybierz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.Select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Poniższy przykład kodu tworzy puste Dictionary<TKey,TValue> ciągi z kluczami ciągu i Add używa metody do dodawania niektórych elementów.The following code example creates an empty Dictionary<TKey,TValue> of strings with string keys and uses the Add method to add some elements. W przykładzie pokazano, że Add Metoda ArgumentException zgłasza podczas próby dodania zduplikowanego klucza.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

W przykładzie zastosowano Item[TKey] Właściwość (indeksator w C#) do pobierania wartości, KeyNotFoundException pokazując, że jest zgłaszany, gdy żądany klucz nie jest obecny i wskazuje, że wartość skojarzona z kluczem może zostać zastąpiona.The example uses the Item[TKey] property (the indexer in C#) to retrieve values, demonstrating that a KeyNotFoundException is thrown when a requested key is not present, and showing that the value associated with a key can be replaced.

Przykład pokazuje, jak użyć metody TryGetValue jako bardziej efektywnego sposobu pobierania wartości, jeśli program często musi wypróbowywać kluczowe wartości, które nie znajdują się w słowniku, i pokazuje, jak użyć metody ContainsKey, aby sprawdzić, czy klucz istnieje przed wywołaniem Add metoda.The example shows how to use the TryGetValue method as a more efficient way to retrieve values if a program often must try key values that are not in the dictionary, and it shows how to use the ContainsKey method to test whether a key exists before calling the Add method.

W przykładzie pokazano, jak wyliczyć klucze i wartości w słowniku oraz jak wyliczyć klucze i wartości przy użyciu Keys właściwości Values i właściwości.The example shows how to enumerate the keys and values in the dictionary and how to enumerate the keys and values alone using the Keys property and the Values property.

Na koniec przykład ilustruje Remove metodę.Finally, the example demonstrates the Remove method.

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

Uwagi

Klasa Dictionary<TKey,TValue> generyczna zapewnia mapowanie z zestawu kluczy do zestawu wartości.The Dictionary<TKey,TValue> generic class provides a mapping from a set of keys to a set of values. Każde dodanie do słownika składa się z wartości i skojarzonego z nim klucza.Each addition to the dictionary consists of a value and its associated key. Pobieranie wartości przy użyciu jej klucza jest bardzo szybkie, blisko o (1), ponieważ Dictionary<TKey,TValue> Klasa jest zaimplementowana jako tablica skrótów.Retrieving a value by using its key is very fast, close to O(1), because the Dictionary<TKey,TValue> class is implemented as a hash table.

Uwaga

Szybkość pobierania zależy od jakości algorytmu wyznaczania wartości skrótu typu określonego dla TKey.The speed of retrieval depends on the quality of the hashing algorithm of the type specified for TKey.

Tak długo Dictionary<TKey,TValue>, jak obiekt jest używany jako klucz w, nie może zmieniać się w żaden sposób, który wpływa na jego wartość skrótu.As long as an object is used as a key in the Dictionary<TKey,TValue>, it must not change in any way that affects its hash value. Każdy klucz w a Dictionary<TKey,TValue> musi być unikatowy w zależności od porównania równości słownika.Every key in a Dictionary<TKey,TValue> must be unique according to the dictionary's equality comparer. Klucz nie może być null, ale wartość może być, jeśli jej typem TValue jest typ referencyjny.A key cannot be null, but a value can be, if its type TValue is a reference type.

Dictionary<TKey,TValue>wymaga implementacji równości, aby określić, czy klucze są równe.Dictionary<TKey,TValue> requires an equality implementation to determine whether keys are equal. Można określić implementację IEqualityComparer<T> interfejsu generycznego za pomocą konstruktora, który comparer akceptuje parametr; Jeśli nie określisz implementacji, zostanie użyta domyślna ogólna funkcja porównująca EqualityComparer<T>.Default równość.You can specify an implementation of the IEqualityComparer<T> generic interface by using a constructor that accepts a comparer parameter; if you do not specify an implementation, the default generic equality comparer EqualityComparer<T>.Default is used. Jeśli typ TKey System.IEquatable<T> implementuje interfejs ogólny, domyślna funkcja porównująca równość używa tej implementacji.If type TKey implements the System.IEquatable<T> generic interface, the default equality comparer uses that implementation.

Uwaga

Można na przykład użyć niewrażliwych na wielkość liter porównywania ciągów dostarczonych przez StringComparer klasę do tworzenia słowników z kluczami ciągów bez uwzględniania wielkości liter.For example, you can use the case-insensitive string comparers provided by the StringComparer class to create dictionaries with case-insensitive string keys.

Pojemność a to liczba Dictionary<TKey,TValue> elementów, które Dictionary<TKey,TValue> mogą być przechowywane.The capacity of a Dictionary<TKey,TValue> is the number of elements the Dictionary<TKey,TValue> can hold. Gdy elementy są dodawane do Dictionary<TKey,TValue>, pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez ponowną alokację tablicy wewnętrznej.As elements are added to a Dictionary<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array.

Tylko .NET Framework: W przypadku bardzo Dictionary<TKey,TValue> dużych obiektów można zwiększyć maksymalną pojemność do 2 000 000 000 elementów w systemie 64-bitowym, enabled ustawiając atrybut <gcAllowVeryLargeObjects> elementu konfiguracji na true w środowisku wykonawczym..NET Framework only: For very large Dictionary<TKey,TValue> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Na potrzeby wyliczenia każdy element w słowniku jest traktowany jako KeyValuePair<TKey,TValue> struktura reprezentująca wartość i jej klucz.For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair<TKey,TValue> structure representing a value and its key. Kolejność, w której zwracane są elementy, jest niezdefiniowana.The order in which the items are returned is undefined.

foreach Instrukcja C# języka(for each C++w ,For Each w Visual Basic) zwraca obiekt typu elementów w kolekcji.The foreach statement of the C# language (for each in C++, For Each in Visual Basic) returns an object of the type of the elements in the collection. Dictionary<TKey,TValue> Ponieważ jest kolekcją kluczy i wartości, typ elementu nie jest typem klucza ani typem wartości.Since the Dictionary<TKey,TValue> is a collection of keys and values, the element type is not the type of the key or the type of the value. Zamiast tego typ elementu jest KeyValuePair<TKey,TValue> typem klucza i typem wartości.Instead, the element type is a KeyValuePair<TKey,TValue> of the key type and the value type. Na przykład:For example:

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

foreach Instrukcja to otoka wokół modułu wyliczającego, która umożliwia odczytywanie danych z kolekcji, a nie zapisywanie w niej.The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

Uwaga

Ponieważ klucze mogą być dziedziczone i ich zachowanie zostało zmienione, ich absolutna unikatowość nie może być gwarantowana przez Equals porównania przy użyciu metody.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Konstruktory

Dictionary<TKey,TValue>()

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy, która jest pusta, ma domyślną pojemność początkową i używa domyślnej wartości porównującej równość dla typu klucza.Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the default initial capacity, and uses the default equality comparer for the key type.

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

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy zawierającej elementy skopiowane z określonego IDictionary<TKey,TValue> i używa domyślnej wartości porównującej równość dla typu klucza.Initializes a new instance of the Dictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the default equality comparer for the key type.

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

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy, która zawiera elementy skopiowane z określonego IDictionary<TKey,TValue> i używa określonego IEqualityComparer<T>.Initializes a new instance of the Dictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the specified IEqualityComparer<T>.

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

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy, która jest pusta, ma domyślną pojemność początkową i używa określonego IEqualityComparer<T>.Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the default initial capacity, and uses the specified IEqualityComparer<T>.

Dictionary<TKey,TValue>(Int32)

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy, która jest pusta, ma określoną pojemność początkową i używa domyślnej wartości porównującej równość dla typu klucza.Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the specified initial capacity, and uses the default equality comparer for the key type.

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

Inicjuje nowe wystąpienie Dictionary<TKey,TValue> klasy, która jest pusta, ma określoną pojemność początkową i używa określonego IEqualityComparer<T>.Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the specified initial capacity, and uses the specified IEqualityComparer<T>.

Dictionary<TKey,TValue>(SerializationInfo, StreamingContext)

Inicjuje nowe wystąpienie klasy Dictionary<TKey,TValue> klasy z serializowanych danych.Initializes a new instance of the Dictionary<TKey,TValue> class with serialized data.

Właściwości

Comparer

Pobiera wartość IEqualityComparer<T> , która jest używana do określania równości kluczy dla słownika.Gets the IEqualityComparer<T> that is used to determine equality of keys for the dictionary.

Count

Pobiera liczbę par klucz/wartość zawartych w Dictionary<TKey,TValue>.Gets the number of key/value pairs contained in the Dictionary<TKey,TValue>.

Item[TKey]

Pobiera lub ustawia wartość skojarzoną z określonym kluczem.Gets or sets the value associated with the specified key.

Keys

Pobiera kolekcję zawierającą klucze z Dictionary<TKey,TValue>.Gets a collection containing the keys in the Dictionary<TKey,TValue>.

Values

Pobiera kolekcję zawierającą wartości Dictionary<TKey,TValue>z.Gets a collection containing the values in the Dictionary<TKey,TValue>.

Metody

Add(TKey, TValue)

Dodaje określony klucz i wartość do słownika.Adds the specified key and value to the dictionary.

Clear()

Usuwa wszystkie klucze i wartości z Dictionary<TKey,TValue>.Removes all keys and values from the Dictionary<TKey,TValue>.

ContainsKey(TKey)

Określa, Dictionary<TKey,TValue> czy zawiera określony klucz.Determines whether the Dictionary<TKey,TValue> contains the specified key.

ContainsValue(TValue)

Określa, Dictionary<TKey,TValue> czy zawiera konkretną wartość.Determines whether the Dictionary<TKey,TValue> contains a specific value.

EnsureCapacity(Int32)

Zapewnia, że słownik może przechowywać maksymalnie określoną liczbę wpisów bez dalszej ekspansji magazynu zapasowego.Ensures that the dictionary can hold up to a specified number of entries without any further expansion of its backing storage.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację przez Dictionary<TKey,TValue>.Returns an enumerator that iterates through the Dictionary<TKey,TValue>.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementuje interfejs i zwraca dane, które są konieczne do Dictionary<TKey,TValue> serializacji wystąpienia. ISerializableImplements the ISerializable interface and returns the data needed to serialize the Dictionary<TKey,TValue> instance.

GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
OnDeserialization(Object)

ISerializable Implementuje interfejs i wywołuje zdarzenie deserializacji po zakończeniu deserializacji.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(TKey)

Usuwa wartość z określonym kluczem z Dictionary<TKey,TValue>.Removes the value with the specified key from the Dictionary<TKey,TValue>.

Remove(TKey, TValue)
ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TrimExcess()

Ustawia pojemność tego słownika, tak jakby był pierwotnie zainicjowany przy użyciu wszystkich jego wpisów.Sets the capacity of this dictionary to what it would be if it had been originally initialized with all its entries.

TrimExcess(Int32)

Ustawia pojemność tego słownika, aby pomieścić określoną liczbę wpisów bez dalszej ekspansji magazynu zapasowego.Sets the capacity of this dictionary to hold up a specified number of entries without any further expansion of its backing storage.

TryAdd(TKey, TValue)

Próbuje dodać określony klucz i wartość do słownika.Attempts to add the specified key and value to the dictionary.

TryGetValue(TKey, TValue)

Pobiera wartość skojarzoną z określonym kluczem.Gets the value associated with the specified key.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection<T> do tablicy, rozpoczynając od określonego indeksu tablicy.Copies the elements of the ICollection<T> to an array, starting at the specified array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do ICollection elementu jest synchronizowany (bezpieczny wątkowo).Gets a value that indicates whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection.

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

Dodaje określoną wartość do ICollection<T> podanego klucza.Adds the specified value to the ICollection<T> with the specified key.

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

Określa, ICollection<T> czy zawiera określony klucz i wartość.Determines whether the ICollection<T> contains a specific key and value.

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

Kopiuje elementy ICollection<T> do tablicy typu KeyValuePair<TKey,TValue>, rozpoczynając od określonego indeksu tablicy.Copies the elements of the ICollection<T> to an array of type KeyValuePair<TKey,TValue>, starting at the specified array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Pobiera wartość wskazującą, czy słownik jest tylko do odczytu.Gets a value that indicates whether the dictionary is read-only.

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

Usuwa klucz i wartość ze słownika.Removes a key and value from the dictionary.

IDictionary.Add(Object, Object)

Dodaje określony klucz i wartość do słownika.Adds the specified key and value to the dictionary.

IDictionary.Contains(Object)

Określa, IDictionary czy zawiera element z określonym kluczem.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

IDictionaryEnumerator Zwraca wartośćIDictionarydla.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

Pobiera wartość wskazującą, czy IDictionary ma stały rozmiar.Gets a value that indicates whether the IDictionary has a fixed size.

IDictionary.IsReadOnly

Pobiera wartość wskazującą, czy jest tylko IDictionary do odczytu.Gets a value that indicates whether the IDictionary is read-only.

IDictionary.Item[Object]

Pobiera lub ustawia wartość z określonym kluczem.Gets or sets the value with the specified key.

IDictionary.Keys

Pobiera zawierający klucze IDictionary. ICollectionGets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

Usuwa element z określonym kluczem z IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values

Pobiera zawierający wartości z IDictionary. ICollectionGets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys

Pobiera zawierający klucze IDictionary<TKey,TValue>. ICollection<T>Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values

Pobiera zawierający wartości z IDictionary<TKey,TValue>. ICollection<T>Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through the collection.

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

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through the collection.

IReadOnlyDictionary<TKey,TValue>.Keys

Pobiera kolekcję zawierającą klucze IReadOnlyDictionary<TKey,TValue>.Gets a collection containing the keys of the IReadOnlyDictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Values

Pobiera kolekcję zawierającą wartości IReadOnlyDictionary<TKey,TValue>.Gets a collection containing the values of the IReadOnlyDictionary<TKey,TValue>.

Metody rozszerzania

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

Tries to get the value associated with the specified key in the dictionary.

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

Tries to get the value associated with the specified key in the dictionary.

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

Tries to remove the value with the specified key from the dictionary.

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

Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

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

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Dictionary<TKey,TValue> Może obsługiwać wielu czytników współbieżnie, o ile kolekcja nie jest modyfikowana.A Dictionary<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Nawet w ten sposób Wyliczanie za pomocą kolekcji nie jest w sposób wewnętrzny bezpieczny dla wątków.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. W rzadkich przypadkach, gdy Wyliczenie jest zgodne z dostępem do zapisu, kolekcja musi być zablokowana w całym wyliczeniu.In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. Aby zezwolić wielu wątkom na dostęp do kolekcji w celu odczytu i zapisu danych, należy zaimplementować własny mechanizm synchronizacji.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

W przypadku alternatywnych wątków zapoznaj się z ConcurrentDictionary<TKey,TValue> klasą ImmutableDictionary<TKey,TValue> lub klasą.For thread-safe alternatives, see the ConcurrentDictionary<TKey,TValue> class or ImmutableDictionary<TKey,TValue> class.

Publiczne statyczne (Shared w Visual Basic) członkowie tego typu są bezpieczne wątkowo.Public static (Shared in Visual Basic) members of this type are thread safe.

Zobacz też