Dictionary<TKey,TValue> Class

Definition

Stellt eine Auflistung von Schlüsseln und Werten dar. Represents a collection of keys and values.

[System.Runtime.InteropServices.ComVisible(false)]
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
Typparameter
TKey

Der Typ der Schlüssel im Wörterbuch. The type of the keys in the dictionary.

TValue

Der Typ der Werte im Wörterbuch. The type of the values in the dictionary.

Vererbung
Dictionary<TKey,TValue>
Abgeleitet
Attribute
Implementiert

Beispiele

Das folgende Codebeispiel erstellt ein leeres Dictionary<TKey,TValue> von Zeichenfolgen mit Zeichenfolgenschlüsseln und verwendet die Add Methode, um einige Elemente hinzuzufügen.The following code example creates an empty Dictionary<TKey,TValue> of strings with string keys and uses the Add method to add some elements. Im Beispiel wird veranschaulicht, die die Add -Methode löst eine ArgumentException beim Versuch, einen doppelten Schlüssel hinzuzufügen.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

Im Beispiel wird die Item[TKey] -Eigenschaft (Indexer in c#) zum Abrufen von Werten, die veranschaulicht, dass eine KeyNotFoundException wird ausgelöst, wenn ein angeforderte Schlüssel nicht vorhanden ist, und zeigt, dass der Wert mit einem Schlüssel zugeordnete ersetzt werden.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.

Im Beispiel wird gezeigt, wie mithilfe der TryGetValue Methode als eine effizientere Methode zum Abrufen der Werte, wenn ein Programm häufig versucht Schlüsselwerte, die nicht im Wörterbuch vorhanden sind, und es zeigt, wie die ContainsKey Methode zu testen, ob ein Schlüssel vorhanden ist, vor dem Aufrufen der Add Methode.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.

Das Beispiel zeigt, wie die Schlüssel und Werte im Wörterbuch aufgelistet werden und wie die Schlüssel aufgelistet werden, und Werte mithilfe von allein die Keys Eigenschaft und die Values Eigenschaft.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.

Zum Schluss das Beispiel veranschaulicht die Remove Methode.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.
 */
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // 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
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.
' 

Hinweise

Die Dictionary<TKey,TValue> generische Klasse stellt eine Zuordnung zwischen einen Satz von Schlüsseln auf einen Satz von Werten.The Dictionary<TKey,TValue> generic class provides a mapping from a set of keys to a set of values. Jede Hinzufügung zum Wörterbuch besteht aus einem Wert und dem zugeordneten Schlüssel.Each addition to the dictionary consists of a value and its associated key. Abrufen eines Werts anhand des zugehörigen Schlüssels ist sehr schnell und schließen, O(1), da die Dictionary<TKey,TValue> Klasse wird als Hashtabelle implementiert.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.

Hinweis

Die Geschwindigkeit der abrufen, hängt die Qualität des Hashalgorithmus des Typs für die angegebenen TKey.The speed of retrieval depends on the quality of the hashing algorithm of the type specified for TKey.

Solange ein Objekt als Schlüssel verwendet wird die Dictionary<TKey,TValue>, sie muss nicht geändert, in keiner Weise, die der Hashwert betroffen sind.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. Jeder Schlüssel im einem Dictionary<TKey,TValue> muss gemäß dem Gleichheitsvergleich des Wörterbuchs eindeutig sein.Every key in a Dictionary<TKey,TValue> must be unique according to the dictionary's equality comparer. Ein Schlüssel kann nicht null, jedoch kann ein Wert, wenn der Werttyp, TValue ein Verweistyp ist.A key cannot be null, but a value can be, if the value type TValue is a reference type.

Dictionary<TKey,TValue> erfordert eine gleichheitsimplementierung auf zu bestimmen, ob die Schlüssel gleich sind.Dictionary<TKey,TValue> requires an equality implementation to determine whether keys are equal. Sie können angeben, dass eine Implementierung von der IEqualityComparer<T> generische Schnittstelle mithilfe eines Konstruktors, die akzeptiert eine comparer Parameter; Wenn Sie eine Implementierung, die den Standardgleichheitsvergleich für den generischen nicht angeben EqualityComparer<T>.Default wird verwendet.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. Wenn Typ TKey implementiert die System.IEquatable<T> generische Schnittstelle, die den Standardgleichheitsvergleich verwendet diese Implementierung.If type TKey implements the System.IEquatable<T> generic interface, the default equality comparer uses that implementation.

Hinweis

Beispielsweise können Sie die Groß-/Kleinschreibung von bereitgestellten Vergleichsschlüssel der StringComparer zu Wörterbüchern mit Zeichenfolgenschlüsseln Groß-/Kleinschreibung zu erstellenden Klasse.For example, you can use the case-insensitive string comparers provided by the StringComparer class to create dictionaries with case-insensitive string keys.

Die Kapazität einer Dictionary<TKey,TValue> ist die Anzahl der Elemente der Dictionary<TKey,TValue> enthalten kann.The capacity of a Dictionary<TKey,TValue> is the number of elements the Dictionary<TKey,TValue> can hold. Wenn Elemente hinzugefügt werden eine Dictionary<TKey,TValue>, die Kapazität wird automatisch erhöht Neuzuordnen des internen Arrays wie erforderlich.As elements are added to a Dictionary<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array.

Für sehr große Dictionary<TKey,TValue> Objekte aufweist, können Sie die maximale Kapazität 2 Milliarden von Elementen auf einem 64-Bit-System erhöhen, durch Festlegen der enabled Attribut des Konfigurationselements, true in der Runtime-Umgebung.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 configuration element to true in the run-time environment.

Bei der Enumeration wird jedes Element im Wörterbuch als behandelt eine KeyValuePair<TKey,TValue> Struktur, die einen Wert und ihrem Schlüssel darstellt.For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair<TKey,TValue> structure representing a value and its key. Die Reihenfolge, in der die Elemente zurückgegeben werden, ist nicht definiert.The order in which the items are returned is undefined.

Die foreach -Anweisung der c#-Sprache (for each in C++ For Each in Visual Basic) gibt ein Objekt des Typs der Elemente in der Auflistung zurück.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. Da die Dictionary<TKey,TValue> ist eine Auflistung von Schlüssel und Werte, die den Elementtyp nicht den Typ des Schlüssels oder den Typ des Werts.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. Der Elementtyp ist hingegen eine KeyValuePair<TKey,TValue> den Typ des Schlüssels und der Werttyp.Instead, the element type is a KeyValuePair<TKey,TValue> of the key type and the value type. Zum Beispiel: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

Die foreach Anweisung ist ein Wrapper um den Enumerator, der nur das Lesen aus der Auflistung zulässt, nicht in den sie schreiben.The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

Hinweis

Da der Schlüssel können übernommen werden, und ihr Verhalten geändert, eine absolute Eindeutigkeit kann nicht garantiert werden bei Vergleichen mit der Equals Methode.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Konstruktoren

Dictionary<TKey,TValue>()

Initialisiert eine neue, leere Instanz der Dictionary<TKey,TValue>-Klasse mit der Standardanfangskapazität, wobei der Standardgleichheitsvergleich für den Schlüsseltyp verwendet wird. 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>)

Initialisiert eine neue Instanz der Dictionary<TKey,TValue>-Klasse, die aus dem angegebenen IDictionary<TKey,TValue> kopierte Elemente enthält und den Standardgleichheitsvergleich für den Schlüsseltyp verwendet. 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>)

Initialisiert eine neue Instanz der Dictionary<TKey,TValue>-Klasse, die aus dem angegebenen IDictionary<TKey,TValue> kopierte Elemente enthält und den angegebenen IEqualityComparer<T> verwendet. 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>)

Initialisiert eine neue, leere Instanz der Dictionary<TKey,TValue>-Klasse mit der Standardanfangskapazität und dem angegebenen 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)

Initialisiert eine neue, leere Instanz der Dictionary<TKey,TValue>-Klasse mit der Standardanfangskapazität, wobei der Standardgleichheitsvergleich für den Schlüsseltyp verwendet wird. 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>)

Initialisiert eine neue, leere Instanz der Dictionary<TKey,TValue>-Klasse mit der angegebenen Anfangskapazität und dem angegebenen 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)

Initialisiert eine neue Instanz der Dictionary<TKey,TValue>-Klasse mit serialisierten Daten. Initializes a new instance of the Dictionary<TKey,TValue> class with serialized data.

Eigenschaften

Comparer

Ruft den IEqualityComparer<T> ab, mit dem die Gleichheit der Schlüssel für das Wörterbuch bestimmt wird. Gets the IEqualityComparer<T> that is used to determine equality of keys for the dictionary.

Count

Ruft die Anzahl der Schlüssel-Wert-Paare im Dictionary<TKey,TValue> ab. Gets the number of key/value pairs contained in the Dictionary<TKey,TValue>.

Item[TKey]

Ruft den Wert ab, der dem angegebenen Schlüssel zugeordnet ist, oder legt diesen fest. Gets or sets the value associated with the specified key.

Keys

Ruft eine Auflistung ab, die die Schlüssel im Dictionary<TKey,TValue> enthält. Gets a collection containing the keys in the Dictionary<TKey,TValue>.

Values

Ruft eine Auflistung ab, die die Werte im Dictionary<TKey,TValue> enthält. Gets a collection containing the values in the Dictionary<TKey,TValue>.

Methoden

Add(TKey, TValue)

Fügt dem Wörterbuch den angegebenen Schlüssel und Wert hinzu. Adds the specified key and value to the dictionary.

Clear()

Entfernt sämtliche Schlüssel und Werte aus dem Dictionary<TKey,TValue>. Removes all keys and values from the Dictionary<TKey,TValue>.

ContainsKey(TKey)

Bestimmt, ob das Dictionary<TKey,TValue> den angegebenen Schlüssel enthält. Determines whether the Dictionary<TKey,TValue> contains the specified key.

ContainsValue(TValue)

Ermittelt, ob die Dictionary<TKey,TValue> einen bestimmten Wert enthält. Determines whether the Dictionary<TKey,TValue> contains a specific value.

EnsureCapacity(Int32)
Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator()

Gibt einen Enumerator zurück, der die Dictionary<TKey,TValue> durchläuft. Returns an enumerator that iterates through the Dictionary<TKey,TValue>.

GetHashCode()

Fungiert als die Standardhashfunktion. Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementiert die ISerializable-Schnittstelle und gibt die zum Serialisieren der Dictionary<TKey,TValue>-Instanz erforderlichen Daten zurück. Implements the ISerializable interface and returns the data needed to serialize the Dictionary<TKey,TValue> instance.

GetType()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
OnDeserialization(Object)

Implementiert die ISerializable-Schnittstelle und löst das Deserialisierungsereignis aus, sobald die Deserialisierung abgeschlossen ist. Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(TKey)

Entfernt den Wert mit dem angegebenen Schlüssel aus dem Dictionary<TKey,TValue>. Removes the value with the specified key from the Dictionary<TKey,TValue>.

Remove(TKey, TValue)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

(Inherited from Object)
TrimExcess()
TrimExcess(Int32)
TryAdd(TKey, TValue)
TryGetValue(TKey, TValue)

Ruft den dem angegebenen Schlüssel zugeordneten Wert ab. Gets the value associated with the specified key.

Explizite Schnittstellenimplementierungen

ICollection.CopyTo(Array, Int32)

Kopiert die Elemente der ICollection<T> in ein Array, wobei am angegebenen Arrayindex begonnen wird. Copies the elements of the ICollection<T> to an array, starting at the specified array index.

ICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert (threadsicher) ist. Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann. Gets an object that can be used to synchronize access to the ICollection.

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)
ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)
ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)
ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly
ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)
IDictionary.Add(Object, Object)

Fügt dem Wörterbuch den angegebenen Schlüssel und Wert hinzu. Adds the specified key and value to the dictionary.

IDictionary.Contains(Object)

Ermittelt, ob das IDictionary ein Element mit dem angegebenen Schlüssel enthält. Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

Gibt einen IDictionaryEnumerator für das IDictionary zurück. Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

Ruft einen Wert ab, der angibt, ob das IDictionary eine feste Größe aufweist. Gets a value indicating whether the IDictionary has a fixed size.

IDictionary.IsReadOnly

Ruft einen Wert ab, der angibt, ob das IDictionary schreibgeschützt ist. Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object]

Ruft den Wert mit dem angegebenen Schlüssel ab oder legt diesen fest. Gets or sets the value with the specified key.

IDictionary.Keys

Ruft eine ICollection ab, die die Schlüssel des IDictionary enthält. Gets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

Entfernt das Element mit dem angegebenen Schlüssel aus dem IDictionary. Removes the element with the specified key from the IDictionary.

IDictionary.Values

Ruft eine ICollection ab, die die Werte im IDictionary enthält. Gets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys
IDictionary<TKey,TValue>.Values
IEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der die Auflistung durchläuft. Returns an enumerator that iterates through the collection.

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()
IReadOnlyDictionary<TKey,TValue>.Keys
IReadOnlyDictionary<TKey,TValue>.Values

Gilt für:

Threadsicherheit

Ein Dictionary<TKey,TValue> gleichzeitige Unterstützung für mehrere Reader, solange die Auflistung nicht geändert wird. A Dictionary<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Trotzdem ist die Enumeration einer Auflistung systemintern keine threadsichere Prozedur. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. In dem seltenen Fall, in denen eine Enumeration mit Schreibzugriffe stellt fest, muss die Auflistung während der gesamten Enumeration gesperrt werden. In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. Um den Lese- und Schreibzugriff auf diese Auflistung durch mehrere Threads zuzulassen, müssen Sie eine eigene Synchronisierung implementieren. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization. Thread-sichere Alternativen finden Sie unter den ConcurrentDictionary<TKey,TValue> Klasse oder ImmutableDictionary<TKey,TValue> Klasse. For thread-safe alternatives, see the ConcurrentDictionary<TKey,TValue> class or ImmutableDictionary<TKey,TValue> class. Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. Public static (Shared in Visual Basic) members of this type are thread safe.

Siehe auch