Question

C# doesn’t require you to specify a generic type parameter if the compiler can infer it, for instance:

List<int> myInts = new List<int> {0,1,1,     2,3,5,8,13,21,34,55,89,144,233,377,     610,987,1597,2584,4181,6765};  //this statement is clunky List<string> myStrings = myInts.     Select<int,string>( i => i.ToString() ).     ToList<string>();  //the type is inferred from the lambda expression //the compiler knows that it's taking an int and  //returning a string List<string> myStrings = myInts.     Select( i => i.ToString() ).     ToList(); 

This is needed for anonymous types where you don’t know what the type parameter would be (in intellisense it shows up as 'a) because it’s added by the compiler.

Class-level type parameters don’t let you do this:

//sample generic class public class GenericDemo<T>  {     public GenericDemo ( T value )      {         GenericTypedProperty = value;     }      public T GenericTypedProperty {get; set;} }  //why can't I do: int anIntValue = 4181; var item = new GenericDemo( anIntValue ); //type inference fails  //however I can create a wrapper like this: public static GenericDemo<T> Create<T> ( T value ) {     return new GenericDemo<T> ( value ); }  //then this works - type inference on the method compiles var item = Create( anIntValue ); 

Why doesn’t C# support this class level generic type inference?

Answer 1

Actually, your question isn’t bad. I’ve been toying with a generic programming language for last few years and although I’ve never come around to actually develop it (and probably never will), I’ve thought a lot about generic type inference and one of my top priorities has always been to allow the construction of classes without having to specify the generic type.

C# simply lacks the set of rules to make this possible. I think the developers never saw the neccesity to include this. Actually, the following code would be very near to your proposition and solve the problem. All C# needs is an added syntax support.

class Foo<T> {     public Foo(T x) { … } }  // Notice: non-generic class overload. Possible in C#! class Foo {     public static Foo<T> ctor<T>(T x) { return new Foo<T>(x); } }  var x = Foo.ctor(42); 

Since this code actually works, we’ve shown that the problem is not one of semantics but simply one of lacking support. I guess I have to take back my previous posting. 😉