Declaration of Anonymous types List [duplicate]

Answer 1

In general you can use the (arguably bad-smelling) cast by example trick others have mentioned to create instances of any generic type parameterized with an anonymous type for the type argument. However, for List<T> there is a slightly less gross way to do it:

var array = new[] {
  new {  
    Name="Krishna",  
    Phones = new[] {"555-555-5555", "666-666-6666"}
  }
};
var list = array.ToList();

Your sketch of a proposed syntax is similar to a feature we did not implement for C# 3 or 4, but we considered. We call the feature "mumble types", and it would go something like this:

List<?> myList = new List<?>() {
  new {  
    Name="Krishna",  
    Phones = new[] {"555-555-5555", "666-666-6666"}
  }
};

We call it "mumble types" because of course you'd read it "myList is a new list of hrmmf". :-)

The idea is that the compiler would look at the initializers and do its best to figure out what the type could possibly be, just the same way as how "var" means "look at the initializer and figure out what the type of the variable is". Whether we'd use "var" as the "mumble" or "?" (which is similar to what Java does in a related feature), or something else is an open question.

In any event, I wouldn't hold my breath waiting for this feature if I were you. It hasn't made the cut for several language versions so far, but it will stay on the list of possibilities for a while longer I think. If, hypothetically speaking, we were to be designing future versions of the language. Which we might or might not be. Remember, Eric's musings about future versions of C# are for entertainment purposes only.

Answer 2

Here's an approach that is somewhat cleaner than many of the other suggestions:

var list = Enumerable.Repeat(new { Name = "", Phones = new[] { "" } }, 0)
               .ToList();

// ...
list.Add(new { Name = "Krishna", 
               Phones = new[] { "555-555-5555", "666-666-6666" } });