C# Dictionary with Examples

Characteristics of Dictionary

C# dictionary is represented by the Dictionary<TKey, TValue> class from the System.Collections.Generic namespace.

Here are the key characteristics of dictionaries in C#:

• Key-Value Pair Storage: A dictionary stores data in key-value pairs, where each element has a unique key associated with a specific value. The key is used to identify and retrieve the corresponding value efficiently.
• Fast Lookup Time: Dictionaries provide fast and efficient data retrieval based on the key. They use a hashing mechanism internally to organize and locate elements quickly. As a result, dictionary lookups have an average time complexity of O(1), making them ideal for scenarios where quick data access is essential.
• Uniqueness of Keys: Each key in a dictionary must be unique. Attempting to add a duplicate key will result in an exception being thrown. Ensuring the uniqueness of keys is crucial for accurate data retrieval and the proper functioning of dictionary operations.
• Generic Type Support: Dictionaries in C# are generic, meaning they can store data of different types, including custom types. You specify the types of keys (TKey) and values (TValue) when creating a dictionary instance, and the compiler enforces type safety.
• No Preserved Order: The Dictionary<TKey, TValue> class does not guarantee the preservation of the insertion order. The order of elements during iteration may not be the same as the order in which elements were added. If you require a specific order, you should use a different collection type, such as List or OrderedDictionary.
• Automatic Resizing: Dictionaries automatically resize themselves to accommodate more elements as needed. When the number of elements exceeds a certain threshold, the dictionary internally allocates more space to ensure efficient data management.
• Key-Based Access: The primary way to access elements in a dictionary is through their keys. To get the value associated with a specific key, you use the indexer ([]) with the key as the index.
• ContainsKey and TryGetValue Methods: Dictionaries provide methods to check if a specific key exists in the collection (ContainsKey) and to safely retrieve a value based on the key (TryGetValue). The TryGetValue method avoids exceptions by returning a Boolean indicating the success of the retrieval operation and storing the value in an output parameter.
• Updating and Removing Elements: We can update the value associated with a key or remove an element from the dictionary using the [] indexer or the Remove method, respectively.
• Capacity Management: Dictionaries have a Capacity property that represents the total number of elements the dictionary can hold before resizing occurs. You can set the capacity explicitly to improve performance when you know the expected number of elements.

Overall, dictionaries are powerful data structures in C# that provide efficient lookup and storage capabilities based on unique keys. They are commonly used in a wide range of applications for fast data retrieval and management.

Steps to Create C# Dictionary

Creating a C# dictionary involves a few simple steps. Here's an overview of the process:

• Import the Required Namespace: Begin by adding the necessary using directive to access the Dictionary<TKey, TValue> class. This class is part of the System.Collections.Generic namespace, which is needed to work with dictionaries. Add the following line at the top of your C# file.

• Choose Key and Value Types: Determine the data types for the keys and values you want to store in the dictionary. The dictionary can hold data of any valid C# data type, including built-in types, custom classes, or structs.

• Declare and Instantiate the Dictionary: Next, declare and create a new instance of the *Dictionary<TKey, TValue> class. Specify the types for keys (TKey) and values (TValue). Use the new keyword to create the instance.

Replace TKey and TValue with the appropriate data types you selected in step 2.

• Add Elements to the Dictionary: You can add key-value pairs to the dictionary using the Add method. The Add method takes two parameters: the key and the associated value.

Replace key and value with the actual data you want to add to the dictionary.

• Access Elements in the Dictionary: To access a value based on its key, use the indexer ([]) with the key as the index.

• Iterate Through the Dictionary: You can use a foreach loop to iterate through the key-value pairs in the dictionary.

Here's the code for creating a dictionary:

OUTPUT:

Updating Dictionary

Updating a dictionary in C# involves modifying the value associated with a specific key. The process can be summarized in the following overview.

• Access the Dictionary

  To update a dictionary, we first need to have access to the dictionary instance we want to modify.

• Choose the Key to Update

  Identify the key for which we want to update the value. The key should be unique within the dictionary, as duplicate keys are not allowed.

• Assign a New Value to the Key

  To update the value associated with the chosen key, use the indexer ([]) with the key as the index and assign the new value to it. The syntax is as follows.

• Updated Value is Saved:

  After assigning the new value to the key, the dictionary automatically updates the value associated with that key. If the key already exists in the dictionary, the value is replaced with the new one. If the key does not exist, a new key-value pair is added to the dictionary.

  Here's a code example demonstrating how to update a dictionary.

OUTPUT:

In this example, we update the value associated with the key "apple" to 15, and then we access the updated value to confirm the change. The output will show "Updated value for 'apple': 15".

Removing Elements from Dictionary

Occasionally, we may encounter situations where we need to remove specific elements from a Dictionary based on certain conditions. However, it's crucial to understand that we cannot directly remove elements from a Dictionary while iterating over it, as it will lead to an exception.

Using a foreach Loop and a Separate List

One of the common approaches to removing elements from a Dictionary is by using a foreach loop to iterate through its items. Since modifying the Dictionary while iterating would cause an exception, we create a separate list to collect the keys of the elements we wish to remove. After the loop, we can safely remove the selected items using the collected keys.

OUTPUT:

• Removing a single element based on its key:

  If we want to remove a single element from the Dictionary based on its key, you can directly use the Remove method.

OUTPUT:

Checking the Availability of Elements in Dictionary

In C#, checking the availability of elements in a Dictionary involves verifying if a particular key or value exists within the Dictionary. The Dictionary class provides methods and properties to accomplish this task. Let's explore how to check for the availability of elements in a Dictionary.

Checking if a Key Exists:

To check if a specific key exists in the Dictionary, we can use the ContainsKey method or use the indexer with a key to access the value and then check for null.

Using ContainsKey method

OUTPUT:

Using indexer and checking for null

OUTPUT:

Checking if a Value exists:

To check if a specific value exists in the Dictionary, we can use the ContainsValue method.

OUTPUT:

Using TryGetValue for both key and value check

As shown in the previous examples, the TryGetValue method can be used to check both the existence of a key and obtain its corresponding value

OUTPUT:

Checking the availability of elements in a Dictionary in C# is straightforward. We can use the ContainsKey, ContainsValue, or TryGetValue methods to determine whether a specific key or value exists in the Dictionary.

By utilizing these techniques, we can make informed decisions in the code based on the presence or absence of elements in the Dictionary, ensuring safer and more efficient program execution.