In this article, we’re going to explore accessing Dictionary items by index in C# and its performance considerations.
The Dictionary<TKey,TValue> generic class provides the ability to map keys to values. Retrieving a value by using its key is quite fast, almost O(1) thanks to the implementation of Dictionary<TKey, TValue> class as a hash table.
Every element of Dictionary is a key-value pair.
While it is optimum to access elements via the key, sometimes we need to access Dictionary items by index. Let’s see how to do that.
Ready? Let’s get started.
Creating a Dictionary
For accessing elements via index, first, we need to create a Dictionary<string, string> object:
var capitals = new Dictionary<string, string>()
{
{"Turkey", "Ankara"},
{"UK", "London"},
{"USA", "Washington"}
};
Nothing special here, just a Dictionary<string, string> object that contains three key-value pairs that we can play with. It uses the country name as the key and the country capital as the value.
Access Dictionary Elements Using Index
When we want to access an element using the index, we are going to use the ElementAt method:
var element = capitals.ElementAt(2);
The ElementAt method provides us array-like access capability to key-value pairs of Dictionary<string, string>.
As with C# arrays, the index of the first element is 0.
So if we type ElementAt(2) we get the value of the third key-value pair of our Dictionary:
[Usa, Washington]
We can even access the key or value of certain elements individually:
Console.WriteLine($"Just Key: {capitals.ElementAt(2).Key}");
Console.WriteLine($"Just Value: {capitals.ElementAt(2).Value}");
If we start our application and test this implementation, we can see that everything works as expected:
[USA, Washington] Just Key: USA Just Value: Washington
Performance Considerations While Using Index
The Dictionary<TKey,TValue> is designed for holding key-value pairs so it is not reasonable to use it with arrays in mind. Yeah, there is an Array class in .NET we can use for such scenarios. So using The Dictionary<TKey,TValue> as an array has a performance penalty.
The Dictionary<TKey,TValue> has no way to access directly the nth “element” via ElementAt. If we want to access the nth “element”, the Dictionary needs to enumerate all of the entries in it. Performance is O(n) and the performance penalty increases with the size of the dictionary.
So each call to the ElementAt method takes time and hence we should use it wisely.
Difference Between Indexer and Access by Index
Sometimes there’s confusion about the usage of the indexer and index access.
The indexer uses TKey of Dictionary<TKey,TValue> to access the value:
Console.WriteLine($"This is the indexer access of the UK capital: {capitals["UK"]}");
Using brackets does not mean we use index value, we used just TKey value of dictionary:
This is indexer access of UK capital: London
Conclusion
As we can see, accessing Dictionary elements via an index is easy, but we have to consider the performance penalties, especially with Dictionaries that have many elements.
So, saying something like “Retrieve the dictionary elements by indexers” is the same as saying “Retrieve the dictionary elements by keys”? I understood it this way.
Hi Stefan. If you access dictionary elements by index then you get both the key and the value as a result. Both of them are on the same index inside the collection. But if you use a key, then you will retrieve only the value for that key.
Ok, distinction understood.
But also what I wanted to confirm is:
About that, please refer here: https://code-maze.com/csharp-indexers/
Wow, this was a great read!! I had no clue about indexers before! Great stuff Marinko, it opened a whole new area of c# to me 😀
Awesom. I’m glad it was usefull to you. That’s the vwry purpose of it.
dict.Select((x, i) => new { Index = i, KeyValuePair = x });We can do something like this to solve this proble
Well as much as I can see, this will return an IEnumerable of anonymous objects with two properties, so you are basically doing a transformation from key-value entries to object entries with two properties where one of the properties is the index itself. Then you still have to extract that one element based on the provided index value.
Dictionary “index” is not guaranteed at all
Hello Steve. Yeah, the indexes may change in dictionary if we add or remove entries. Still, you can extract the element from dictionary using the index and we just tried to explain how to do that in this article. Now, that you have mentioned this case, maybe we should update the article. Anyhow your comment is valuable even if we don’t do that.
It is guaranteed if you are just adding. Order is preserved.
There’s another data structure in .NET that supports indexing and O(1) lookup. The implementation internally stores a list and dictionary. You can use System.Collections.ObjectModel.Collection<T>.