Why Prefer Collection Initializer

Since C# 6, Object Initializer allowed us to access Indexer. This resulted in a shift in using the Object Initializer to initialize collections including Dictionary instead of Collection initializers. But does this have a hidden threat ? This blog post explores the hidden threads of this approach.

When it was first introduced, object initializer wasn't allowed to access indexer. This changed in C# 6, and we could now access the indexer within the object initializer. This eventually lead to a common initializing pattern which we often encouter in our daily code. 

var dictionary = new Dictionary<int,string>
{
    [0] = "value 1",
    [1] = "value 2",
};

In the above code, we used the object initializer to initialize the Dictionary. Prior to C# 6, we used Collection Initializer to initialize a collection. For example,

var dictionary = new Dictionary<int,string>
{
    {0,"value 1"},
    {1,"value 2"},
};

Of course the object initializer syntax looks more concise and cleaner, but are there any hidden threats with the approach ?

 

While both codes look similiar, they are accomplishing the objective via two different approaches, which results in different behaviors under certain circumstance, particularly if you were to accidently slip in a duplicate entry. 

// Using Object Initializer
var dictionary = new Dictionary<int,string>
{
    [0] = "value 1",
    [1] = "value 2",
    [1] = "value 3"
};

// Using Collection Initializer.
var dictionary = new Dictionary<int,string>
{
    {0,"value 1"},
    {1,"value 2"},
    {1,"value 3"}
};

If one was to execute the above two code snippets, the approach using object initializer not throw any exception, while the approach using collection initializer would raise the much needed exception notifying the developer about the duplicate entry.

 

To understand why this happens, let us examine what happens behind each of them. The object initalizer would be translated to the following. 

Dictionary<int, string> dictionary = new Dictionary<int, string>();
dictionary[0] = "value 1";
dictionary[1] = "value 2";
dictionary[1] = "value 3";

The object initializer, after C# 6, allowed us to access the indexers and assign the value. This would mean, if there are duplicates, they are overwritten. Using the object initializer syntax, dictionary[1] == "value 3" holds true. The value 2 value gets overwritten with value 3 in the above example.

 

This is different when using the collection initializer. The collection initializer effectively calls the Add() method with appropriate signature. This would mean the approach with Collection Initializer would translate as

Dictionary<int, string> dictionary = new Dictionary<int, string>();
dictionary.Add(0,"value 1");
dictionary.Add(1,"value 2");
dictionary.Add(1,"value 3");

Obviously, adding a duplicate key would throw an exception in this case. As a developer, I must admit that  chances of accidental duplicates aren't that rare. Such mistakes could happen to any developer. Under such circumstances, it would be preferable that the exceptions be raised rather than values being overwritten without any notification.

 

Considering both approaches, it might be recommmended to use the collection initializers rather than depending on object initializer when dealing with Collections even if the syntax looks less concise than the object initializer.