Question

In Java I can have a method declaration something like this:

<T> List<T> getList(final Class<T> objectClass, String whatever)

Which means that I specify the list return type by specifying the Class to the method.

List<Customer> customers = getList(Customer.class, "blah");

And if I don’t specify the classes properly I get a compile time error. (which is what I’m looking for – I want the compiler to catch a mismatch).

List<String> customers = getList(Customer.class, "blah"); // will not compile

What’s the equivalent of this in C#?
TIA

Answer 1

There is no way in C# to have the compiler infer the generic type based on the return type.

In C#, you must specify T if the only differentiation is the return type:

List<Customer> customer = getList<Customer>("blah");

This method would be written as:

List<T> getList<T>(string whatever) { ... }

However, in C#, type inference is automatically handled if there is a parameter that takes a type of customer. For example, you can have:

List<T> MakeList<T>(params T[] items) { ...}

Then call this as (without <Customer>):

 Customer one = GetCustomer(1);
 Customer two = GetCustomer(2);

 var customers = MakeList(one, two);

---

Edit in response to comment:

If you are going to be constructing a new “Customer” inside of your method, and want this to work on any type, you’ll need a new constraint in place. To have this:

List<Customer> customers = GetList<Customer>("blah");

You would need something like:

List<T> GetList<T>(string whatever) 
   where T : new() // This lets you construct it internally
{
     List<T> results = new List<T>();

     /// ...
     T newInstance = new T();

     results.Add(newInstance);
     return results;
}

That being said, if you’re going to make a method like this, chances are you’ll also want to have a constraint to an interface, so you can setup the object you create:

List<T> GetList<T>(string whatever) 
   where T : ISomeInterface, new()

This will let you use properties of ISomeInterface within the method, as well as limit it to only working with types that implement that interface.