为什么不能在数组中交换匿名类型的属性？

Question

I know that in C# I can declare an array of anonymous types like this:

var anons = new[]
{
    new { name = "" , something = ""},
    new { name = "", something = "" }
};

I can understand that all the objects need to have the same properties, or else one won't be able to iterate through them and use those properties like:

foreach (var anon in anons)
{
    Console.WriteLine(anon.name);
}

But what I don't understand is why do their properties need to have the same order?

For example, the following code won't compile:

var anons = new[]
{
    new { name = "" , something = ""},
    new { something = "", name = "" }
};

Why isn't this allowed, since in a normal object, the properties can be declared no matter their order, and the rest of the code could use them, as it does right now?

Answer 1

From the documentation for anonymous types: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/anonymous-types

If two or more anonymous object initializers in an assembly specify a sequence of properties that are in the same order and that have the same names and types , the compiler treats the objects as instances of the same type. They share the same compiler-generated type information.

In other words, you're creating two anonymous types and the sequence of property names and property types don't match. They look pretty much the same to us, but the compiler sees them as two different types, which means that it can't infer one type for the array declaration.

Answer 2

Even though the answer given by Scott is virtually correct, it does not answer the why question entirely. Since this is a question more about the compiler design regarding anonymous types array, and most of us can't come up with a clear answer, I will keep the question open and postpone accepting an answer until somebody answers the why question. Meanwhile I will leave here the following theory:

To the question

why do their properties need to have the same order?

Why not?

Since one can declare an array of anonymous types right now, having the possibility to swap the order of the properties within objects would not help anybody.

Contrarily to this, changing the order of the properties of an anonymous object within the objects of an array of anonymous types can be misleading and for the sake of consistency should be avoided. In this case, a warning or a at least a message should be displayed for the programmers who are trying to swap the properties of the objects like that so why not making it an error from the beginning and remove the need to make the C# compiler smart enough to sort out the properties itself.

In conclusion: Having the properties always in the same order is not a missing functionality, but a feature.