What's the C# equivalent of Java's Class<X> type?

Question

In Java, it's convenient for Class to have the generic parameter, X. But C#'s Type class doesn't have this.

So in C#, how does one do the equivalent of the following Java code?:

public <X> X methodThatReturns(Class<X> clazz) { ... }

There doesn't seem to be a way in C# to connect that return values, and the passed Type.

Clarification
Several answers are suggesting the method parameter isn't necessary, because the method could simply be defined as methodThatReturns<X>().

But if you do have some unknown Type variable, t, there's basically no way to call such a generic method so that it will return an object of Type t?

In Java, you're free to pass around Class<X> variables without losing the type information, but it seems that in C# if you pass around the equivalent Type variables, you can run into limitations, because you can't use them when you need to call generic methods.

Answer 1

I'm familiar with both Java and .NET generics and I use the Class<X> construct like that a lot in my Java projects. One of my favorite uses is to deal with non-generic collections in Java which are returned from outside code like Hibernate (I think that the latest version of Hibernate might support generics, though I'm not certain of that. We are using a rather old version of it since it is a long running project that has too much code that would have to be updated if we ever changed it.) The function works like this:

public <X> List<X> TypedList(List<?> lst, Class<X> cls) {
    return (List<X>) lst;
}

It's all very simple and the important thing is I don't have to create a dummy object to pass to the function, I just call it as:

List<MyObject> myLst = TypedList(lst, MyObject.class);

Another important thing to note is that the cls parameter isn't used at all. It's only means of giving a concrete type for X.

The way that you do this same thing is a little bit different in C#. You might think that the same function would look something like this:

public List<X> TypedList<X>(IList lst)
{
    return (List<X>) lst;
}

But you would be dead wrong.

The problem is that Java uses a trick called Type Erasure, which basically means that when the code is actually compiled, ALL generic parameters are removed from the code. So in the world of the Java Virtual Machine, there is no such thing as a List<X> or any other generics, they are all simple List and other non-generic types. This means that the generics are only there to help you code and are not enforced at runtime.

In C#, however, there is no type erasure and generics are enforced at runtime. This means that the following would generate a runtime exception when used with the above function:

List<object> lstObj = TypedList<object>(new List<string>());

The reason is that List<string> and List<object> are considered two completely different classes. You can't even do List<object> lstObj = (List<object>) new List<string>(); without getting a compiler error. This means the function cannot return the same object that was passed to it. We must create a new object of the correct type and return that one. The most basic form of this would look like the following:

public List<X> TypedList<X>(IList lst)
{
    List<X> lstOut = new List<X>();
    for (int i = 0; i < lst.Count; i++)
    {
        if (lst[i] is X) lstOut.Add((X) lst[i]);
    }
    return lstOut;
}

That's rather boring and boilerplate code, but it works. For something much shorter and cleaner, LINQ is here to save the day. Check out the following:

public List<X> TypedList<X>(IList lst)
{
    return lst.OfType<X>().ToList();
}

OfType<X>() grabs all items in lst that are of the type X (or descendants) and skips over any that aren't. ToList() then builds a new List<X> containing all the members passed to it from OfType<X>(). Another advantage to this method is that we can actually change the lst parameter from being an IList to IEnumberable, which is implemented by all collection types.

One other thing to point out about this though is that it doesn't do any conversion of types, only type checking. So that means that if you wanted to take a List<long> and convert it to a List<int> or a List<string>, you would need to do something else. With LINQ, this would still be very simple:

List<long> lstLng = new List<long>();
lstLng.Add(1);
List<int> lstInt = lstLng.Cast<int>().ToList();
List<string> lstStr = lstLng.Select(lng => lng.ToString()).ToList();

[NOTE: If you aren't familiar with the lng => lng.ToString() part, it is called a Lambda Expression.]

Cast<int>(), unlike OfType<int>(), actually tries to convert each item to an int, skipping over any items that fail to convert. Select() just lets you build a whole new collection from your existing collection, using almost any kind of code you want.

I hope my real world examples help people to understand better the differences between .NET and Java when it comes to using functions with generic types.

Answer 2

public X methodThatReturns<X>(Class<X> clazz) { ... }

Also keep in mind that in C# there is no type erasure so you can do things like typeof(T) without worries in case Class is meant to be the java "Class" object rather than a "some class" placeholder:

public X methodThatReturns<X>(X value)
{
    Type x = typeof(X); // that's fine
    if (value is SomeType) { } // that's fine too    
    return (X)someObject; // I think you get the point
}

Edit:

Again, since the generic type information is not lost after compilation you don't need to pass in the type explicitly:

public X methodThatReturns<X>()
{
    Type xType = typeof(X); // Type is to C#/.Net what Class<X> is to Java.
}

Answer 3

I'm not 100% up on Java generics... Are you trying to declare a method that returns the same type as it was passed?

public T MethodThatReturns<T>(T input) { ... }

This method will be generic on any type, and return the same type it was passed. You can call this using:

AnyTypeAtAll foo = new AnyTypeAtAll();
AnyTypeAtAll bar = MethodThatReturns(foo);

Note that there's no <AnyTypeAtAll> on the call to MethodThatReturns, the compiler can figure it out given the parameter you passed. However, note that it's the compiler doing that, not runtime, so it'll only use the type of variable foo, not the type of object that foo points to.

---

On the other hand, if that's Java syntax for a method that takes no 'real' parameters, then simply:

public T MethodThatReturns<T>()
{
    Type clazz = typeof(T);
    ....
}

Within this method, you can treat T the same as you would any other class, and it will refer specifically to the type that the method was called with, not to object or anything like that. You may want to put where T : class to allow comparison to null in that method (which does prevent you from using int as the generic type), or where T : new() to restrict the generic type to have a default constructor, so you can do T foo = new T();

Answer 4

In C# it would be

public X methodThatReturns<X>() { ... }

and you can get type of X using typeof(X) instead of using the parameter clazz