Object initializer syntax confusion. Using parentheses in initializer?

Question

So I was looking at the documentation to understand how to use an object initializer, be it for anonymous types or not. The only thing that I would like to find out is why(and if it matters) is there a difference in the example.

It goes like this: for a Cat

class Cat
{
    public int Age { get; set; }
    public string Name { get; set; }
}

I can see the first example like so:

Cat cat = new Cat { Age = 10, Name = "Fluffy" };

This makes sense. But then, you can find the following:

List<Cat> cats = new List<Cat>
{
    new Cat(){ Name = "Sylvester", Age=8 },
    new Cat(){ Name = "Whiskers", Age=2 }
};

Now my question is: (why) is there a difference between new Cat{...} and new Cat(){...} ? Why should we use(or not) the parentheses?

Answer 1

These are just two acceptable equivalent syntax for instantiation of objects in C# with object initialization (you can't omit the parenthesis if you are just doing var cat = new Cat();).

• since your class has no explicit constructor, a default parameter-less constructor is provided to the Cat class
• new Cat {...} allows to instantiate and initialize properties of the Cat object as a shortcut for new Cat() {...}, calling the mentioned constructor.

The part about the constructor is important. If there is no implicit default constructor / explicit parameter-less constructor, then you cannot omit the parenthesis, and you'll have to provide parameters in them anyway :

public class Cat {
    public string Name;
    public int Age;

    public Cat(string s) { // since I provide a constructor with parameter here, no parameterless constructor exists
        Name = s; 
    } 
}

// ...
void TestCat() 
{

    // compilation error : 'Cat'' does not contain a constructor that takes 0 arguments
    //var badCat1 = new Cat { Name = "Felix", Age = 3} ;
    //var badCat2 = new Cat() { Name = "Felix", Age = 3} ;

    // works (but no way to remove parenthesis here, since there are parameters to pass to csontructor)
    var goodCat = new Cat("Felix") { Age = 3 } ;

    Console.WriteLine($"The cat {goodCat.Name} is {goodCat.Age} years old");
}

---

Special case : (which is used a lot for collections, list, dictionaries, etc...).

If a class T implements IEnumerable (i.e. has a IEnumerable GetEnumerator() public function), and implements an Add method, then the object initializer will use the Add method with the collection on enumeration.

Example from https://blog.mariusschulz.com/2014/06/26/fun-with-custom-c-collection-initializers

Creation of special class "Points" which acts like a "List" with the initialization.

Note that this also uses the existing parameter-less constructor !

public class Points : IEnumerable<Point3D>
{
    private readonly List<Point3D> _points;

    public Points()
    {
        _points = new List<Point3D>();
    }

    public void Add(double x, double y, double z)
    {
        _points.Add(new Point3D(x, y, z));
    }

    public IEnumerator<Point3D> GetEnumerator()
    {
        return _points.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Used like that :

var cube = new Points
{
    { -1, -1, -1 },
    { -1, -1,  1 },
    { -1,  1, -1 },
    { -1,  1,  1 },
    {  1, -1, -1 },
    {  1, -1,  1 },
    {  1,  1, -1 },
    {  1,  1,  1 }
};

Answer 2

If an object has a parameterless constructor, you can omit the parentheses. So both of these are valid

// Assuming cat has a constructor with no parameters
Cat cat = new Cat { Age = 10, Name = "Fluffy" };
Cat cat = new Cat() { Age = 10, Name = "Fluffy" };

The List<T> itself has an object initializer where you can provide any number of items, and they are automatically added to the collection.

List<Cat> cats = new List<Cat>()
{
    new Cat(){ Name = "Sylvester", Age=8 }, // Add sylvester to the List
    new Cat(){ Name = "Whiskers", Age=2 } // And Whiskers too
};

As mentioned above you can also remove the parentheses here aswell

List<Cat> cats = new List<Cat>
{
    new Cat { Name = "Sylvester", Age=8 }, // Add sylvester to the List
    new Cat { Name = "Whiskers", Age=2 } // And Whiskers too
};