Advertisement

---

Top

< Prev

The generic Dictionary<TKey, TValue> collection class stores a collection of key-value pairs, where key and value are objects.

The Dictionary<TKey, TValue> uses a mechanism of hashing to store each key-value pair and to perform the association between each key-value pair. In hashing, a unique hash code of each key is computed internally and this value of hash code is used as an index at which its associated value is stored in the Dictionary<TKey, TValue>.

Dictionary<TKey, TValue> collection class is defined in the System.Collections.Generics namespace and it implements IDictionary, IDictionary<TKey, TValue>, ICollection, IEnumerable<KeyValuePair<TKey, TValue>> and many other interfaces.

Some important features of Dictionary<TKey, TValue>

• A null cannot be stored as a key.
• A null can be stored as a value.
• Dictionary<TKey, TValue> elements are ordered on the basis of hash code value of each key(which is computed internally) & hence the order of key-value pairs may appear different as compared to their insertion order.
• Dictionary<TKey, TValue> allows the execution time of retrieving an element, lookup and set operations to remain near constant, even for large sets.

The Dictionary<Key,TValue> class is implemented as a hash table, therefore, retrieving a value by using its key is very fast.

Constructors of Dictionary<TKey, TValue>

Constructor	Description
Dictionary<T>()	This constructor creates an empty instance of the Dictionary<TKey, TValue> class by using the default initial capacity, hash code provider, and comparer. The capacity of a Dictionary<TKey, TValue> is the number of elements it can hold, as the new elements are added to the Dictionary<TKey, TValue>, its capacity is automatically increased.
Dictionary<T>(int capacity)	This constructor initializes created a Dictionary<TKey, TValue> that is empty and has the specified initial capacity.
Dictionary<T>(IDictionary<TKey, TValue>)	This constructor creates a Dictionary<T> initialized with the elements of an IDictionary<TKey, TValue> collection.

Properties of Dictionary<TKey, TValue>:

Properties	Description
Capacity	This property is used to get or set the total number of elements a Dictionary<TKey, TValue> can hold.
Count	This property gives total number of elements in a Dictionary<TKey, TValue>.
IsFixedSize	This property determines whether a Dictionary<TKey, TValue> has a fixed size or not.
IsReadOnly	This property determines whether a Dictionary<TKey, TValue> is read-only or not.
IsSynchronzied	This property determines whether a Dictionary<TKey, TValue> is thread-safe or not.
Item[Object key]	This property gets or sets a value associated with the specified key in theDictionary<TKey, TValue>. To use this property, you should not type Item, but you only need to specify the specific key within a pair of square brackets [ ]
Keys	This property gets an ICollection<TKey> containing the keys of aDictionary<TKey, TValue>.
Values	This property gets an ICollection<TValue containing the values of aDictionary<TKey, TValue>.

Some methods in a Dictionary<TKey, TValue>.

As Dictionary<TKey, TValue> implements Map interface, so some methods are inherited from Map.

Methods	Description
int Add(TKey key, TValue value)	This method adds the specified key-value pair in Dictionary<TKey, TValue>.
bool Contains(TKey key)	This method checks if Dictionary<TKey, TValue> contains a specific key.
bool ContainsKey(TKey key)	This method checks if Dictionary<TKey, TValue> contains a specific key.
bool ContainsValue(TKey key)	This method checks if Dictionary<TKey, TValue> contains a specific value.
void Clear()	This method removes all of the elements from the Dictionary<TKey, TValue>.
int GetHash(TKey key)	This method returns the hash code for the specified key.
Dictionary<TKey, TValue>.Enumerator GetEnumerator()	This method returns to enumerate the entire Dictionary<TKey, TValue>.
void Remove(TKey key)	This method removes the element with the specified key in the Dictionary<TKey, TValue>.

Dictionary<TKey, TValue> example

In the upcoming example, we will create a Dictionary<TKey, TValue> to store objects in the form of key-value pair of objects, where:
• Each key is a String object.
• Each key's associated value is an int and because C# has a unified type system, so any primitive values like int, char, float, etc are implicitly boxed into an Object references.

We will iterate over all the key-value pairs and we will also obtain a value on the basis its key.

//C# Example of Dictionary<TKey, TValue>

using System;
using System.Collections.Generic;

class DictionaryDemo
{
public static void Main(String[] ar)
{
	//Creating a Dictionary<TKey, TValue>
	//Where, Keys are of type String
	//And, Values are of type int
	Dictionary<String, int> dict = new Dictionary<String, int>();

	//Adding key-value pairs by the Add() method
	dict.Add("Max", 1000);
	dict.Add("John", 4000);
	dict.Add("Tom", 2000);
	dict.Add("Ana", 6000);
	dict.Add("Rick", 5000);

	//Getting a collection of the keys using property Keys
	ICollection<String> c = dict.Keys;
	
	// Use the keys to obtain the values.
	foreach(String str in c)
		Console.WriteLine(str + ": " + dict[str]);

	//Using the property Item to retrieve the value of key "Tom"
	//Remember the property Item is not used with its name
	Console.WriteLine("Value at the key, Tom is "+ dict["Tom"]);

	//Using the property Item to retrieve the value of key "Ana"
	Console.WriteLine("Value at the key, Ana is "+ dict["Ana"]);
}
}

Output is :

Max: 1000
John: 4000
Tom: 2000
Ana: 6000
Rick: 5000
Value at the key, Tom is 2000
Value at the key, Ana is 6000

Program Analysis

• In the code above, we have created a generic Dictionary<TKey, TValue> to store objects, where each key is a String and its associated value is an int and because C# has a unified type system, so any primitive values like int, char, float are implicitly boxed into an Object references.
• The method Add() is called to add the values of key-value pair by specifying a key and its value.
• Next, we have retrieved a collection of the keys stored in the Dictionary<TKey, TValue>, by using its property Keys, and using which, we have iterated over each value stored in the Dictionary<TKey, TValue>.
• Next we have used the Item[key] property of the Dictionary<TKey, TValue>(which is used without specifying the word Item), to obtain a value associated with a particular key in a Dictionary<TKey, TValue>.

Advertisement

Checking if Dictionary<TKey, TValue> contains a specific key or a specific value

In this example of Dictionary<TKey, TValue> we will perform two operations:
• We will determine if the Dictionary<TKey, TValue> contains a specific key by using the methods, ContainsKey(Object).
• We will determine if the Dictionary<TKey, TValue> contains a specific value by using the method, ContainsValue(Object).




//C# Checking if Dictionary<TKey, TValue> contains a specific key or a specific value

using System;
using System.Collections.Generic;

class DictionaryDemo
{
public static void Main(String[] ar)
{
	//Creating a Dictionary<TKey, TValue>
	//Where, Keys are of type String
	//And, Values are of type int
	Dictionary<String, int> dict = new Dictionary<String, int>();


	//Adding key-value pairs by theAdd() method
	dict.Add("Max", 1000);
	dict.Add("John", 4000);
	dict.Add("Tom", 2000);
	dict.Add("Ana", 6000);
	dict.Add("Rick", 5000);


	//Getting a collection of the keys using property Keys
	ICollection<String> c = dict.Keys;
	

	// Use the keys to obtain the values.
	Console.WriteLine("The contents of Dictionary<TKey, TValue>:");
	foreach(String str in c)
		Console.WriteLine(str + ": " + dict[str]);



	//Calling the method ContainsKey() to see if Dictionary<TKey, TValue> contains key "Ana"
	Console.WriteLine("Does our Dictionary<TKey, TValue> contains the key, Tom: "+ dict.ContainsKey("Ana"));


	//Calling the method ContainsKey() to see if Dictionary<TKey, TValue> contains key "Jack"
	Console.WriteLine("Does our Dictionary<TKey, TValue> contains the key, Jack: "+ dict.ContainsKey("Jack"));


	//Calling the method ContainsValue() to see if Dictionary<TKey, TValue> contains value 4000
	Console.WriteLine("Does our Dictionary<TKey, TValue> contains the value, 4000: "+ dict.ContainsValue(4000));


	//Calling the method ContainsValue() to see if Dictionary<TKey, TValue> contains value 10000
	Console.WriteLine("Does our Dictionary<TKey, TValue> contains the value, 10000: "+ dict.ContainsValue(10000));
}
}





Output is :

The contents of Dictionary<TKey, TValue>:
Max: 1000
John: 4000
Tom: 2000
Ana: 6000
Rick: 5000
Does our Dictionary<TKey, TValue> contains the key, Tom: True
Does our Dictionary<TKey, TValue> contains the key, Jack: False
Does our Dictionary<TKey, TValue> contains the value, 4000: True
Does our Dictionary<TKey, TValue> contains the value, 10000: False








Removing elements from a Dictionary<TKey, TValue>



In this example of Dictionary<TKey, TValue>, first we will create a Dictionary<TKey, TValue> to store objects in the form of key-value pair of objects, where:
• Each key is a char value, and because C# has a unified type system, so any primitive values like int, char, float, etc are implicitly boxed into an Object references.
• Each value is a String object.


Next, we will call the Remove(Object) method to remove the elements of a Dictionary<TKey, TValue>. This method is passed a specific key of Dictionary<TKey, TValue>, and if its exits, the method removes the key and its associated value i.e. it removes the whole key-value pair from the Dictionary<TKey, TValue>.



//C# Removing elements from a Dictionary<TKey, TValue>

using System;
using System.Collections.Generic;

class DictionaryDemo
{
public static void Main(String[] ar)
{
	//Creating a Dictionary<TKey, TValue>
	//Where, Keys are of type char
	//And, Values are of type String
	Dictionary<char, String> hm = new Dictionary<char, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	hm.Add('B', "Banana");
	hm.Add('M', "Mango");
	hm.Add('G', "Grapes");
	hm.Add('A', "Apple");
	hm.Add('O',"Orange");


	//Getting a collection of the keys using property Keys
	ICollection<char> c = hm.Keys;
	

	// Use the keys to obtain the values.
	Console.WriteLine("The contents of Dictionary<TKey, TValue>:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + hm[ch]);


	//Calling the method Remove() to remove a key 'A' and its associated value
	hm.Remove('A');

	//Calling the method Remove() to remove a key 'M' and its associated value
	hm.Remove('M');

	//Printing all elements of Dictionary<TKey, TValue>
	Console.WriteLine("The updated contents of Dictionary<TKey, TValue> after removing keys 'A' and 'M' and their values:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + hm[ch]);
}
}





Output is :

The contents of Dictionary<TKey, TValue>:
A: Apple
G: Grapes
B: Banana
O: Orange
M: Mango
The updated contents of Dictionary<TKey, TValue> after removing keys 'A' and 'M' and their values:
G: Grapes
B: Banana
O: Orange








A key in Dictionary<TKey, TValue> cannot be null



In this example of Dictionary<TKey, TValue>, we will show you how inserting a null value for a key, throws an exception.



//C# Key cannot be null in a Dictionary<TKey, TValue>

using System;
using System.Collections.Generic;

class DictionaryDemo
{
public static void Main(String[] ar)
{
	//Creating aDictionary<TKey, TValue> of type, Dictionary<String,String>
	//Where keys are of type String and values are of type String
	Dictionary<String, String> dict = new Dictionary<String, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	dict.Add("B", "Banana");
	dict.Add("Ma", "Mango");
	dict.Add("Gr", "Grapes");
	dict.Add("Ap", "Apple");
	dict.Add("Or", "Orange");
	dict.Add(null, "no value");	//Trying to store a null as a key
}
}





Output

Unhandled Exception: System.ArgumentNullException: Value cannot be null.
Parameter name: key
   at System.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at DictionaryDemo.Main(String[] ar)


As you can see, the program has thrown a ArgumentNullException because Key cannot be null.






A value in Dictionary<TKey, TValue> can be null



In this example of Dictionary<TKey, TValue>, we will show you how inserting a null for a value is completely allowed and doesn't throws an exception.



//C# A value can  be null in a Dictionary<TKey, TValue>

using System;
using System.Collections.Generic;

class DictionaryDemo
{
public static void Main(String[] ar)
{
	//Creating a Dictionary<TKey, TValue>
	//Where, keys are of char type and values of String type
	Dictionary<char, String> dict = new Dictionary<char, String>();


	//Adding key-value pairs by theAdd() method
	//Where, each key is a character and each value is a String.
	dict.Add('B', "Banana");
	dict.Add('M', "Mango");
	dict.Add('N', null);	//Trying to store a null as a key
	dict.Add('G', "Grapes");
	dict.Add('A', "Apple");
	dict.Add('O', "Orange");
	


	//Getting a collection of the keys using property Keys
	ICollection<char> c = dict.Keys;
	

	//Printing the key-value pairs by using the collection of keys to obtain their values.
	Console.WriteLine("The contents of Dictionary<TKey, TValue>:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + dict[ch]);

}
}





Output

The contents of Dictionary:
B: Banana
M: Mango
N:	
G: Grapes
A: Apple
O: Orange


As you can see, the program has not thown any exception even when we have specified a null as a value for a key N.





Please share this article -






< Prev
< C# Generic HashSet



Advertisement