C# Dictionary Class
Last Updated :
31 Jan, 2025
Improve
In C#, the Dictionary class is the part of the System.Collections.Generic namespace. It is a Collection that stores Key-value pairs. Each key in the dictionary is unique and each key maps to a single value.
- In Dictionary, each entry consists of a key and its associated value.
- It provides constant time complexity for insertion, deletion, and lookups.
- It provides generic support (which means it can work with any data type for both keys and values.
Example: This example, demonstrates how to create a Dictionary, insert key-value pairs and iterate through them to display the keys and their corresponding values.
// C# Program to add elements in a Dictionary
using System;
using System.Collections.Generic;
class Geeks
{
static void Main()
{
// Create a dictionary to store key-value pairs
Dictionary<string, int> d = new Dictionary<string, int>();
// Insert elements into the dictionary
d.Add("Geek1", 1);
d.Add("Geek2", 2);
d.Add("Geek3", 3);
// Display all key-value pairs in the dictionary
foreach (var i in d)
{
Console.WriteLine($"key: {i.Key}, value: {i.Value}");
}
}
}
Output
key: Geek1, value: 1 key: Geek2, value: 2 key: Geek3, value: 3
Declarartion of Dictionary
In C#, the declaration of Dictionary can be done as:
Dictionary<TKey, TValue> dictionaryName = new Dictionary<TKey, TValue>();
Parameters:
- TKey: Denotes the type of the keys in the dictionary.
- TValue: Denotes the type of the values in the dictionary.
Note: Tkey is the type of the keys and Tvalue is the type of the values
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. Instead, the element type is a KeyValuePair <TKey, TValue> of the key type and the value type.
Constructors
| Constructors | Description |
|---|---|
| Dictionary<TKey, TValue>() | 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>) | 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>) | 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>(IEqualityComparer<TKey>) | 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) | Initializes a new instance of the Dictionary 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>) | 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) | Initializes a new instance of the Dictionary<TKey,TValue> class with serialized data. |
Example: This example demonstrates the count of pairs and displaying all the key-value pairs.
// C# Program to create a Dictionary
using System;
using System.Collections.Generic;
class Geeks {
public static void Main()
{
// Create a new dictionary of
// strings, with string Keys
Dictionary<string, string> d =
new Dictionary<string, string>();
// Adding key/value pairs in d
d.Add("1", "C");
d.Add("2", "C++");
d.Add("3", "Java");
d.Add("4", "Python");
// To get count of key-value pairs in dictionary
Console.WriteLine("Total no of pairs"+
" in Dictionary are: " + d.Count);
// Displaying the key-value pairs in dictionary
Console.WriteLine("\nThe key-value pairs"+
" in Dictionary are: ");
foreach(KeyValuePair<string, string> i in d)
{
Console.WriteLine("Key = {0}, Value = {1}",
i.Key, i.Value);
}
}
}
Output
Total no of pairs in Dictionary are: 4 The key-value pairs in Dictionary are: Key = 1, Value = C Key = 2, Value = C++ Key = 3, Value = Java Key = 4, Value = Python
Properties
| Properties | Description |
|---|---|
| Comparer | Gets the IEqualityComparer<TKey, TValue> that is used to determine equality of keys for the dictionary. |
| Count | Gets the number of key/value pairs contained in the Dictionary<TKey, TValue>. |
| Item[TKey] | Gets or sets the value associated with the specified key. |
| Keys | Gets a collection containing the keys in the Dictionary<TKey, TValue>. |
| Values | Gets a collection containing the values in the Dictionary<TKey, TValue>. |
Example 1: This program demonstrates how to retrieve and display all the keys from the dictionary.
// C# Program to get the keys
// in the Dictionary
using System;
using System.Collections.Generic;
class Geeks {
public static void Main()
{
// Create a new dictionary of
// strings, with string keys
Dictionary<string, string> d
= new Dictionary<string, string>();
// Adding key/value pairs
d.Add("1", "C");
d.Add("2", "C++");
d.Add("3", "Java");
d.Add("4", "Python");
// To get count of key-value pairs
Console.WriteLine("Total key-value pairs are: "
+ d.Count);
// To get the keys alone, use the Keys property.
Dictionary<string, string>.KeyCollection keyColl
= d.Keys;
// The elements of the KeyCollection
// are strongly typed with the type
// that was specified for dictionary keys
foreach(string s in keyColl)
{
Console.WriteLine("Key = {0}", s);
}
}
}
Output
Total key-value pairs are: 4 Key = 1 Key = 2 Key = 3 Key = 4
Example 2: This program demonstrates how to retrieve and display all the values from the dictionary.
// C# Program to get the values
// in the Dictionary
using System;
using System.Collections.Generic;
class Geeks {
public static void Main()
{
// Create a new dictionary of
// strings, with string keys
Dictionary<string, string> d =
new Dictionary<string, string>();
// Adding key-value pairs
d.Add("1", "C");
d.Add("2", "C++");
d.Add("3", "Java");
d.Add("4", "Python");
// To get count of key-value pairs
Console.WriteLine("Total key-value pairs are: "
+ d.Count);
// To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl =
d.Values;
// The elements of the ValueCollection
// are strongly typed with the type
// that was specified for dictionary values.
foreach(string s in valueColl)
{
Console.WriteLine("Value = {0}", s);
}
}
}
Output
Total key-value pairs are: 4 Value = C Value = C++ Value = Java Value = Python
Methods
| Method | Description |
|---|---|
| Add(TKey, TValue) | Adds the specified key and value to the dictionary. |
| Clear() | Removes all keys and values from the Dictionary<TKey, TValue>. |
| ContainsKey(TKey) | Determines whether the Dictionary<TKey, TValue> contains the specified key. |
| ContainsValue(TValue) | Determines whether the Dictionary<TKey, TValue> contains a specific value. |
| Equals(Object) | Determines whether the specified object is equal to the current object. |
| GetEnumerator() | Returns an enumerator that iterates through the Dictionary<TKey, TValue> . |
| GetHashCode() | Serves as the default hash function. |
| GetObjectData(SerializationInfo, StreamingContext) | Implements the ISerializable interface and returns the data needed to serialize the Dictionary<TKey,TValue> instance. |
| GetType() | Gets the Type of the current instance. |
| MemberwiseClone() | Creates a shallow copy of the current Object. |
| OnDeserialization(Object) | Implements the ISerializable interface and raises the deserialization event when the deserialization is complete. |
| Remove(TKey) | Removes the value with the specified key from the Dictionary<TKey, TValue>. |
| ToString() | Returns a string that represents the current object. |
| TryGetValue(TKey, TValue) | Gets the value associated with the specified key. |
Example 1: This example demonstrates how to use clear() to remove all the elements from the dictionary.
// C# Program to remove all entries
// from Dictionary
using System;
using System.Collections.Generic;
class Geeks {
public static void Main()
{
// Create a new dictionary of
// strings, with string keys
Dictionary<string, string> d
= new Dictionary<string, string>();
// Adding key/value pairs
d.Add("1", "C");
d.Add("2", "C++");
d.Add("3", "Java");
d.Add("4", "Python");
// To get count of key-value pairs
Console.WriteLine("Total key-value pairs: "
+ d.Count);
d.Clear();
// To get count of key-value pairs
Console.WriteLine(
"Total key-value pairs after Clear operation: "
+ d.Count);
}
}
Output
Total key-value pairs: 4 Total key-value pairs after Clear operation: 0
Example 2: This example demonstrates how to remove entries based on their keys.
// C# code to remove the entry with
// the specified key from the Dictionary
using System;
using System.Collections.Generic;
class Geeks {
public static void Main()
{
// Create a new dictionary of
// strings, with string keys
Dictionary<string, string> d =
new Dictionary<string, string>();
// Adding key/value pairs in d
d.Add("1", "C");
d.Add("2", "C++");
d.Add("3", "Java");
d.Add("4", "Python");
// To get count of key/value pairs
Console.WriteLine("Total key-value pairs: "
+ d.Count);
// Remove the entry with the
// specified key from the Dictionary
d.Remove("1");
d.Remove("3");
// To get count of key-value pairs
Console.WriteLine("Total key-value pairs after removal: "
+ d.Count);
}
}
Output
Total key-value pairs: 4 Total key-value pairs after removal: 2
