Inline property initialisation and trailing comma

void Main()
{
    Test t = new Test
    开发者_开发知识库{
        A = "a",
        B = "b", // <-- erroneous trailing comma
    };
}

public class Test
{
    public string A { get; set; }
    public string B { get; set; }
}

I find the above typo in my code quite a lot. I'm always suprised that the compiler doesn't seem to care about this. Why is the above not a syntax errror? Is there any actually valid use for it?

I find the above typo in my code quite a lot. I'm always suprised that the compiler doesn't seem to care about this. Why is the above not a syntax errror?

Because the people designing the C# syntax grammar were smart enough to learn the lessons from other programming languages which didn't allow the dangling comma, to the constant irritation of programmers in those languages.

For example, ECMAScript (JavaScript) was silent on the issue initially, and so naturally some implementations (SpiderMonkey in Firefox, Opera's JavaScript, etc.) allowed them while others (Microsoft's JScript) didn't. And so this led to a spate of "why doesn't this work in IE" questions here and elsewhere. (Fortunately, ECMAScript 5 explicitly allows them, and IE8 finally supports them in object initializers -- IE8 still treats array initializers in a non-standard way, though to be fair the dangling comma for those was only clarified in ECMAScript 5, too.)

You find this in lots of other places in the C# grammar too, like enums and array initializers.

It's not an error because it's convenient. To add to the initializer, you only have to add in one line instead of adding a comma to one line and entering a whole new line.

This is actually fairly common in list/array initialization in other languages too (Python, Ruby, Haskell come to mind).

I think it's allowed to simplify automatic code generation.

In this case you can have some sort of your program create code like this

...
for( char c = 'A'; c < 'Z'; c++ )
{
   AddToOutput( c + " = \"+c.ToLower()+"\"," );
}
...

And don't have to care about removing the last trailing comma.