Question

What is the limitation of

public class A
{
     public string Stuff {get;set;}
}

...

repository.GetAll().Select(x=> new A { x.Stuff });

That doesn’t work. You have to add

{ Stuff = x.Stuff }

repository.GetAll().Select(x=> new { x.Stuff });

But this works. It creates an anon class with a very similar definition to class A.

Conceptually I don’t see a big difference in what is going on here. Anyone shed some light?

Answer 1

The short answer – the C# compiler and language team didn’t implement it this way – they either didn’t think of it (unlikely) or decided that it was not a good idea….

repository.GetAll().Select(x=> new A { x.Stuff });

That doesn’t work. You have to add

This is an object initializer. This works by calling the default constructor on an object, and then matching property names to a value, ie: Stuff = x.Foo, and is really just a shortcut for matching properties, so the syntax is really just “short hand” for:

A tmp = new A();
tmp.Stuff = x.Stuff;

Now, I suppose the compiler team could have assumed that an initialization statement with no left hand side on the equation should search for a matching property where the name matched and the type was implicitly convertible, but I suspect this would fall into the realm of “flirting with the bad idea list” if or when it would’ve been discussed by the language team. In general, C# is fairly explicit in its syntax, and this would be loosening that up a bit in a way that requires two separate matches (name + type) and would be non-obvious in many scenarios. Since you’re working with a public API here (A), it’d also be very easy for a refactoring in either side (A or whatever type “x” is defined as being) to break this completely.

Finally, this also isn’t really necessary – if you want an instance of A to be constructed this way, just add a constructor with an overload (which is safer in many ways in any case), and use:

repository.GetAll().Select(x=> new A(x.Stuff));

This makes the intention and meaning very explicit, and takes out the brittle maintainability.

repository.GetAll().Select(x=> new { x.Stuff });

This is doing something completely different – here, you’re initializing an anonymous type, and letting the compiler completely determine the type names and types for you. I suspect this was determined to be “safe” since you’re never really working with a public API – anonymous types aren’t really supposed to “leak” out of the method where it’s defined. The risk of having a refactoring change a property name and effectively change values, etc, gets dramatically reduced and isolated to a single method in this case, which in turn keeps this “automatic” naming feature lower risk overall. Also, there isn’t an easy alternative here, as you can’t define constructors on anonymous types, so there wouldn’t be a simple way to have a concise syntax in this case. This adds benefit without introducing a lot of risk.