Question

Suppose I have an interface: IFoo<T1,T2> and a class Moo<T1> : IFoo<List<T1>, Stack<T1>>.

At runtime I can call: typeof(Moo<>).GetInterfaces() and it gives me an array with one type in it, so I guess that in some sense the type typeof(IFoo<List<>, Stack<>>) can be created at runtime. However, that syntax does not work.

What is the correct syntax to define that type at runtime?

Answer 1

I guess that in some sense the type typeof(IFoo<List<>, Stack<>>) can be created at runtime.

Though that statement is true, your logic is not sound because the true conclusion does not follow logically from the premise you’ve stated. The type returned by

typeof(Moo<>).GetInterfaces()[0]

is not IFoo<T1, T2> constructed with List<> and Stack<> in the first place.

Rather, it is IFoo<T1, T2> constructed with List<T1> and Stack<T1>, where T1 is the T1 of Moo<T1>, not the T1 of IFoo<T1, T2>. When making sample code to discuss type construction, I strongly discourage you from making type parameters that are logically different but have the same name. It is very confusing.

In case that is not clear, let’s take a step back. Every generic type has an associated type called its instance type, which is the generic type constructed with its own type parameters. That is, when you say:

class C<T>
{
    Type type1 = typeof(C<T>);
    Type type2 = typeof(C<>);
}

From the compiler’s perspective, the types C<> and C<T> are the same type. But these will be different type objects at runtime because of course at runtime there will never be an instance of C<T>, only C<int> or C<string> or whatever. The first typeof syntax gives you the type as it is constructed at runtime. The second gives you the instance type from the perspective of the compiler.

So let’s consider your case in more detail. Suppose you have:

interface I<T, U> {}
class C<V> {}
class D<W> {}
class E<X> : I<C<X>, D<X>> {}

then typeof(E<>).GetInterfaces()[0] is the type as it is known to the compiler, namely, I<C<X>, D<X>>. But I<C<>, D<>> is a completely different type; that is I<C<V>, D<W>> which is not at all the same type from the compiler’s perspective.

What is the correct syntax to define that type at runtime?

There is none.

There is no C# typeof syntax that produces the type “generic type constructed with type arguments that are the instance types of other generic types”. That would be:

typeof(I<,>).MakeGenericType(typeof(C<>), typeof(D<>)) 

To give you I<C<V>, D<W>>.

Nor is there a typeof syntax for “generic type constructed with the type parameters of a different generic type”. kvb’s answer gives the Reflection code needed to build I<C<X>, D<X>>.

I am curious as to why you would want to construct such a bizarre type in the first place. What’s your application?