This documentation is archived and is not being maintained.

IDictionary(Of TKey, TValue) Interface

Represents a generic collection of key/value pairs.

Namespace:  System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

'Declaration
Public Interface IDictionary(Of TKey, TValue) _
	Inherits ICollection(Of KeyValuePair(Of TKey, TValue)),  _
	IEnumerable(Of KeyValuePair(Of TKey, TValue)), IEnumerable
'Usage
Dim instance As IDictionary(Of TKey, TValue)

Type Parameters

TKey

The type of keys in the dictionary.

TValue

The type of values in the dictionary.

The IDictionary(Of TKey, TValue) interface is the base interface for generic collections of key/value pairs.

Each element is a key/value pair stored in a KeyValuePair(Of TKey, TValue) object.

Each pair must have a unique key. Implementations can vary in whether they allow key to be Nothing. The value can be Nothing and does not have to be unique. The IDictionary(Of TKey, TValue) interface allows the contained keys and values to be enumerated, but it does not imply any particular sort order.

The foreach statement of the C# language (For Each in Visual Basic, for each in C++) requires the type of each element in the collection. Since each element of the IDictionary(Of TKey, TValue) is a key/value pair, the element type is not the type of the key or the type of the value. Instead, the element type is KeyValuePair(Of TKey, TValue). For example:

For Each kvp As KeyValuePair(Of Integer, String) In myDictionary
    ...
Next kvp

The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

NoteNote:

Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Notes to Implementers:

The implementing class must have a means to compare keys.

The following code example creates an empty Dictionary(Of TKey, TValue) of strings, with integer keys, and accesses it through the IDictionary(Of TKey, TValue) interface.

The code example uses the Add method to add some elements. The example demonstrates that the Add method throws ArgumentException when attempting to add a duplicate key.

The example uses the Item 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.

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 how to use the ContainsKey method to test whether a key exists prior to calling the Add method.

Finally, the example shows how to enumerate the keys and values in the dictionary, and how to enumerate the values alone using the Values property.

Imports System
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main() 

        ' Create a new dictionary of strings, with string keys,  
        ' and access it through the IDictionary generic interface. 
        Dim openWith As IDictionary(Of String, String) = _
            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 icoll As ICollection(Of String) = 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  icoll
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        icoll = openWith.Keys

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

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360, Zune

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0

.NET Compact Framework

Supported in: 3.5, 2.0

XNA Framework

Supported in: 3.0, 2.0, 1.0
Show: