C# Dictionary – A Primer On When And How To Use

In our previous article, we were checking out the very basics of dictionaries in C#. We explored what dictionaries are, how to create them, and how to perform basic operations. In this article, we’ll look at more use cases for a dictionary in C# along with how the dictionary class stacks up against some other collection types.

As we move forward, we’ll delve deeper, exploring more advanced aspects of dictionaries that will empower you to use them more effectively in your C# projects. This article will be followed by a third in the series that will focus on more advanced use cases. Did you still need a primer on dictionaries in C# though?

YouTube player

Alright, let’s dive in!


Traversing a C# Dictionary

Aside from looking up dictionary elements by key, traversing dictionaries is also important. One of the most common tasks you’ll find yourself doing with dictionaries is iterating through them. This often stems from the need to want a list of key-value pairs but with distinct keys in the collection. Keep in mind that this may be convenient, but not necessarily optimal because you’ll be using an iterator to get each pair out.

Let’s see how we can traverse a dictionary using loops to iterate over the entries:

Dictionary<string, int> fruits = new Dictionary<string, int>
{
    {"apple", 5},
    {"banana", 3},
    {"cherry", 7}
};

foreach (KeyValuePair<string, int> item in fruits)
{
    Console.WriteLine($"Key: {item.Key}, Value: {item.Value}");
}

You can also look at keys and values independently on the dictionary if you need to. This means that we can use properties on the dictionary class to allow us to iterate through them separately:

foreach (string key in fruits.Keys)
{
    Console.WriteLine($"Key: {key}");
}

foreach (int value in fruits.Values)
{
    Console.WriteLine($"Value: {value}");
}

Common CSharp Dictionary Operations

Beyond the basics, there are several operations that you’ll frequently use when working with dictionaries:

Checking if a Key Exists:

Before trying to access a value in a dictionary, it’s a good practice to check if the key exists:

if (fruits.ContainsKey("apple"))
{
    Console.WriteLine($"Apple count: {fruits["apple"]}");
}

Counting Elements:

To find out how many key-value pairs are in a dictionary:

int count = fruits.Count;
Console.WriteLine($"There are {count} fruits in the dictionary.");

Also, we know that counting how many of a specific key exists is trivial because it’s either 0 or 1 and we can use ContainsKey(). However, if you want to know how many times a specific value appears, the dictionary class is not well suited for this. You would need to iterate through the elements or use some other data structure (maybe another dictionary?!) to track the counts.

Clearing a CSharp Dictionary:

If you need to remove all items from a dictionary:

fruits.Clear();

Other CSharp Dictionary Operations:

If you haven’t read the first post, it will be a great primer to go back and check up on! Between this article and the first, most of the primary use-cases for a dictionary should be covered.

Looking for something more advanced? Don’t you worry! There’s a follow-up to this article where we’ll consider things like concurrency and other situations that a standard dictionary might not fit perfectly right out of the box.


CSharp Dictionary vs. Other Collections in C#

Dictionaries, lists, and arrays are among the most commonly used collections in C#. Each has its own strengths and ideal use cases. Let’s break down their differences and understand when to use one over the other.

Dictionaries:

  • Key-Value Pairs: The most distinguishing feature of dictionaries is their key-value pair structure. This allows for quick lookups based on a unique key.
  • Unordered: Dictionaries, especially before .NET Core 3.0, don’t guarantee the order of elements. This means that the order in which items are added might not be the order in which they’re retrieved.
  • No Duplicates: Each key in a dictionary must be unique. This ensures that there’s always a one-to-one relationship between keys and values.

Lists:

  • Ordered Collection: Lists maintain the order of elements. The first item added is the first item you retrieve, and so on.
  • Duplicates Allowed: Lists don’t have a constraint on uniqueness. The same value can appear multiple times.
  • Dynamic Size: Lists can grow or shrink in size, making them versatile for collections where the number of items isn’t known in advance.

Arrays:

  • Fixed Size: Once an array is defined, its size can’t be changed without creating a new array.
  • Fast Access: Arrays provide quick access to elements based on their index.
  • Memory Efficient: Due to their fixed size and simple structure, arrays can be more memory efficient than other collections in C#.

Comparative Analysis:

  • Access Time: Dictionaries excel when you need to quickly access an element using a key, offering O(1) average time complexity. Lists and arrays, on the other hand, require O(n) time complexity for searching elements unless the index is known.
  • Use Cases: If you’re dealing with a collection where each item has a unique identifier, dictionaries are the way to go. For collections in C# where order matters, lists are ideal. If you have a fixed number of items and need a memory-efficient solution, arrays are your best bet.
  • Flexibility vs. Performance: Dictionaries and lists offer more flexibility in terms of adding or removing items. Arrays, due to their fixed size, can offer better performance in certain scenarios but lack the flexibility of the other two.

When to Use a CSharp Dictionary Over Other Collections:

  • Fast Lookups: When you need to quickly find an item based on a unique key.
  • Ensuring Uniqueness: When you want to ensure that there’s no duplication of certain values (the keys).
  • Unconcerned with Order: When the order of items isn’t crucial to the functionality of your application.

By understanding the strengths and weaknesses of dictionaries, lists, and arrays, developers can make informed decisions about which collection to use based on their specific needs. Keep in mind that we’re only scratching the surface here! If you are focused on performance you should consider benchmarking your code!

Conclusion

Dictionaries are versatile and powerful collections in C#. As we’ve seen in this article, they offer a range of operations that can make your coding tasks more efficient. From traversing dictionaries to understanding their advantages over other collections in C#, we’ve expanded our knowledge of this essential data structure.

Stay tuned for our next article, where we’ll dive into even more advanced topics, pushing the boundaries of what we can achieve with dictionaries in C#! If you don’t want to miss out, subscribe to my weekly newsletter so you can stay up to date on new content!

Nick Cosentino

Principal Software Engineering Manager at Microsoft. Views are my own.

Leave a Reply