When is the generic type resolved in c#?

Question

According to this answer at stackoverflow, the generic type in C# is resolved at runtime.

However, according to this answer, in C#, the generic type is resolved at compile time.

What am I missing here?

In other words, is the type T resolved at compile time or run time?

Update:

Based on Oded's answer, In a case like this, where the type is a closed concrete type (which means it would be resolved at compile time)

class Program
{
    static void Main()
    {
        var t = new Test<int>();
    }  
}

public class Test<T>
{   
}

will the MSIL have the equivalent of

class Program
{
    static void Main()
    {
        var t = new Test();
    }
}

public class Test<int>
{        
}

Answer 1

The problem is that the question is not well-posed. Two people are claiming opposite things: that types are "resolved" at runtime and that types are "resolved" at compile time.

Since they are contradicting each other, they must both mean something different by "resolved".

I do not know what it means for a type to be "resolved". I do know however what overload resolution is. When asked to solve an overload resolution problem that does not involve dynamic, the C# compiler determines which overload to call at compile time, based on the compile time information about the generic type. So for example, if you have:

static void Main()
{
    var d = new D();
    var p = new P<D>();
    p.N(d);//Displays In class B
}


class B
{
    public void M()// Note, not virtual
    {
        Console.WriteLine("In class B");
    }
} 

class D : B
{
    public new void M()// new, not overload
    {
        Console.WriteLine("In class D");
    }
} 

class P<T> where T : B
{
    public  void N(T t)
    {
        t.M();
    }
}

N always calls B.M even if P<T> is instantiated as P<D>. Why? Because the overload resolution problem that determines what the meaning of t.M is must be solved when P<T>.N is compiled, and at that time, the best the compiler knows is that t must be B, so it chooses B.M.

If that's not what you mean by "resolved" then clarify the question.

Answer 2

You are missing the concepts of open and closed generic types.

Essentially, a closed generic type is when you actually specify existing types on a generic parameter/s (or they are inferred by the compiler). For example:

Nullable<int> nulInt;

An open generic type is one where one or more generic type is to be determined during runtime (so, the Nullable<T> class is an example).

Answer 3

1. the first answer is about method parameters
2. and the second is about generic type parameters

this is what you're missing.

more precisely: 1. C# is statically typed by default, so when passing parameters you'll get the best fitting type and method. (Also check out the answer about "dynamic" parameters.) 2. Setting a generic type parameter by the C# syntax is about static types. Setting it by reflection is about something else.

something else: "in .NET" each type has an initialization phase at its first usage at runtime. (see static fields and static constructor)

so: All types are initialized at runtime, but static types are used (or dynamic...) at compile-time that's when they need to be "resolved".

Answer 4

Open types (myclass<T>) do not exist run time. But unbound types can exist at run time (myclass<>). To resolve an unbound type at runtime , you need to use typeof operator.

In other words, unless typeof operator is used, generic types are closed at compile time.

Answer 5

The answer from your first link (generics at runtime) is incorrect. Generics in C# is compile time types, which code will be generated by compiler. But Just in Time (JIT) will set the concrete used type during the first run. Ref J.Richter, 4th edition, Generics, p. 315