Initializing a Generic.List in C#

Question

In C#, I can initialize a list using the following syntax.

List<int> intList= new List<int>() { 1, 2, 3 };

I would like to know how that {} syntax works, and if it has a name. There is a constructor that takes an IEnumerable, you could call that.

List<int> intList= new List<int>(new int[]{ 1, 2, 3 });

That seems more "standard". When I deconstruct the default constructor for the List I only see

this._items = Array.Empty;

I would like to be able to do this.

CustomClass abc = new CustomClass() {1, 2, 3};

And be able to use the 1, 2, 3 list. How does this work?

Update

Jon Skeet answered

It's calling the parameterless constructor, and then calling Add:

> List<int> tmp = new List<int>();
> tmp.Add(1); tmp.Add(2); tmp.Add(3);
> List<int> intList = tmp;

I understand what is does. I want to know how. How does that syntax know to call the Add method?

Update

I know, how cliche to accept a Jon Skeet answer. But, the example with the strings and ints is awesome. Also a very helpful MSDN page is:

• Object and Collection Initializers (C# Programming Guide)

Solution 1

This is called a collection initializer. It's calling the parameterless constructor, and then calling Add:

List<int> tmp = new List<int>();
tmp.Add(1);
tmp.Add(2);
tmp.Add(3);
List<int> intList = tmp;

The requirements for the type are:

• It implements IEnumerable
• It has overloads of Add which are appropriate for the argument types you supply. You can supply multiple arguments in braces, in which case the compiler looks for an Add method with multiple parameters.

For example:

public class DummyCollection : IEnumerable
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new InvalidOperationException("Not a real collection!");
    }

    public void Add(string x)
    {
        Console.WriteLine("Called Add(string)");
    }

    public void Add(int x, int y)
    {
        Console.WriteLine("Called Add(int, int)");
    }
}

You can then use:

DummyCollection foo = new DummyCollection
{
    "Hi",
    "There",
    { 1, 2 }
};

(Of course, normally you'd want your collection to implement IEnumerable properly...)

Solution 2

Read Object and Collection Initializers (C# Programming Guide). Basically you could this with every custom type that is a list (implements IEnumerable).

Solution 3

They're called collection initializers (also see here), and the way they work is by looking for an Add() method that can do their bidding. It calls Add() for each of the integers you have in your curly braces.

The search for the Add() method is pure compiler magic. It's hardcoded to find a method of that name.

Solution 4

The name you're loooking for is "Collection Initializer". It works under the hood by looking for a method named Add on the collection type and calling it for every value that you specify.

More details: Object and Collection Initializers (C# Programming Guide)

Solution 5

I believe it's a shortcut to the .Add method. I've never tried to override it, though, so I don't know if it's possible.

View more solutions

Comments

[Jhonny D. Cano -Leftware-]

It is possible, try implementing an IDictionary

[meandmycode]

So why does it care that the type is enumerable? it doesn't seem to add anything other than making C# more aware of .NET, similar to IDisposable.. makes me wonder why foreach requires JUST a compat signature, and not interfaces.. I thought the idea was so C# wouldn't be specifically tied to a 'lang'

[Jon Skeet]

@meandmycode: foreach isn't tied to IEnumerable because pre-generics there was no other way of exposing an iterator without boxing. With generics I'm sure it would have just relied on IEnumerable<T>. (Continued)

[Jon Skeet]

As for collection initializers requiring IEnumerable, it's a good indication that the type really is a collection type, rather than another type which just happens to have an Add method (e.g. DateTime.Add).

[geekley]

I wish I could use array initializer-like syntax for collections too without having to repeat the type. Like this: List<int> a = {}. Or at least something like in Java List<MyReallyLongTypeName> a = new List<>(). Instead I get CS0622

[geekley]

Ah just found out that this is available in C#9 as List<int> a = new() { ... }. Awesome!