[C# 3.0+] Initialiser Syntax

[jmcilhinney]

VB version here.

C# 3.0 introduced initialiser syntax, which allows you to initialise the property values of a newly created object in a block that is basically attached to the constructor, e.g.

SomeType myObject = new SomeType { Property1 = value1, Property2 = value2 };

You might ask what's the use of this. Why is it any better than doing this:

SomeType myObject = new SomeType();
 
myObject.Property1 = value1;
myObject.Property2 = value2;

Well, it's a bit more succinct than that for a start, but that's not where the real advantage lies. The property (or field) initialisation is actually part of the expression that returns a reference to the newly created object. As such you can use initialiser syntax in places where you couldn't use a conventional pattern because it would require multiple lines of code. One example is when initialising member variables, e.g.

private SomeType myObject = new SomeType { Property1 = value1, Property2 = value2 };

Normally you'd have to set the properties in the form's Load event handler or something like that. Just note that the values must be literals or static members. Instance members are not available outside a method or property in C# as they are in VB.

Another place where this is useful is when you want to create one object and then pass it to the constructor, or some method, of a second, but you want to set one or more properties of the first object. Previously you'd have had to do something like this:

SomeType obj1 = new SomeType();
 
obj1.SomeProperty = someValue;
 
SomeOtherType obj2 = new SomeOtherType(obj1);

Now you can do this:

SomeOtherType obj2 = new SomeOtherType(new SomeType { SomeProperty = someValue });

This is not a revolutionary change, but it does let you keep your code more concise in certain circumstances.

One thing I would caution against is using initialiser syntax in situations where it actually makes your code harder to read, which may happen if you nest too deeply or have lines that are too long. To help avoid this in certain circumstances, I strongly recommend using line continuation to make your code more readable, e.g.

SomeType myObject = new SomeType { Property1 = value1,
                                   Property2 = value2 };