That is a nasty bug!

I think its easier to understand íf you just remove the breaklines from the statement

var doc = new Dictionary<string, object>
{
    ["@metadata"] = new Dictionary<string, object> {["@id"] = "users/1"}["Name"] = "Oren"
}

Isn't it another issue that the code is using object initializers on collections instead of collection initalizers?

    var doc = new Dictionary<string, object>
    {
        {"@metadata", new Dictionary<string, object>
            {
                {"@id", "users/1"}
            } 
        },
        {"Name", "Oren"}
    };
    
    Console.WriteLine(doc["Name"]);

That example code is just terrible for easy debugging. I think people should use object initializers with care. Better use an extra variable for better readability and better debugging.

I'm confused. The original code as is gives KeyNotFoundException , but this reads as if it doesn't...

But what I don't understand, and your explanation code doesn't clarify, is why ["Name"] = "Oren" works at all? It's outside of the collection initializer.

Why does this compile, and why does test1 end up being a String? Why is the Dictionary initialization being bypassed?

var item = new Dictionary<string, object>() {} ["Name"] = "Oren";
Console.WriteLine(item); //Returns "Oren"
Console.WriteLine(item.GetType()); //Returns System.String

It seems to me this is a C# bug, because it only works with var. Neither of these compiles.

string item = new Dictionary<string, object>() {} ["Name"] = "Oren";
Dictionary<string, object>() item = new Dictionary<string, object>() {} ["Name"] = "Oren";

It took me a while to see the syntax parsing, and remember that C# can be very forgiving of spaces. I'm not a beginner, but it's sort of a beginner mistake. For other readers like me who aren't as bright (if you have any!), here's another look.

While it appeared to me an element was being set completely outside of the declaration, the element is being set on the declared dictionary.

The final syntax is:

var item = NewDictionary[element] = value;

But that syntax can look like this:

var item = NewDictionary              [element] = value;

Code samples

//spaces before the element don't matter
var item = new Dictionary<string, object> {}    ["a"] = 1;
//is the same as
var item = new Dictionary<string, object> { }["a"] = 1;

//For clarity, we replace the declaration with its assignment.
var dic = new Dictionary<string, object> {};
var item = dic     ["a"] = 1;
//is the same as
var item = dic["a"] = 1;

I looked for other examples of where this can be done. The simplest array case doesn't compile:

//This is OK.
int[] items = new int[1] {1};
int item = items [0] = 2;

//But this isn't.
int[] items = new int[1] { 1 } [0] = 2;

Hashtable works the same as Dictionary, which is logical.

//OK
var h = new Hashtable();
h [0] = 1;

//OK, too.
var h = new Hashtable() [0] = 1;

Thanks for getting my brain working!