Question

Assume I have a class library project name Utilities.dll as follows:

public static class Utilities
{
    public static T Min<T>(T[] data) where T : IComparable<T>
    {
        T min = data[0];
        foreach (T x in data)
        {
            if (x.CompareTo(min) < 0)
                min = x;
        }
        return min;
    }
}

Then I create a new console app project Tester.exe referencing Utilities.dll as follows

class Program
{
    static void Main(string[] args)
    {
        int[] data = { 3, 2, 4, 5, 1, 0, -1, 10 };

        Console.WriteLine(Utilities.Min<int>(data));
    }
}

I want to know how the compiler does its job behind the scene. Can anybody know the rough idea about it?

Note that: Assume I have no access to the source code of Utilities.dll when using it on Tester.exe project. Only Utilities.dll is provided.

Answer 1

In .NET (and unlike things like C++), it is the runtime that provides generics. The IL is structured to retain all the generic information (contrasting to Java, which uses type erasure).

In fact, you can create a new Type on the fly (via TypeBuilder), and use reflecton:

Type someCrazyNewType = InventType(...); // not shown
Type listType = typeof(List<>).MakeGenericType(someCrazyNewType);
IList list = (IList)Activator.CreateInstance(listType);

OT, but re your specific example, I actually recommend a change:

var comparer = Comparer<T>.Default;
foreach (T x in data)
{
    if (comparer.Compare(x, min) < 0)
        min = x;
}

This will work even if x is null, and supports “lifted” comparisons (against Nullable<T>). You can also then remove the generic constraint.

But if we look at your original function, the IL is:

.method public hidebysig static !!T Min<([mscorlib]System.IComparable`1<!!T>) T>(!!T[] data) cil managed
{
    .maxstack 2
    .locals init (
        [0] !!T min,
        [1] !!T x,
        [2] !!T[] CS$6$0000,
        [3] int32 CS$7$0001)
    L_0000: ldarg.0 
    L_0001: ldc.i4.0 
    L_0002: ldelem.any !!T
    L_0007: stloc.0 
    L_0008: ldarg.0 
    L_0009: stloc.2 
    L_000a: ldc.i4.0 
    L_000b: stloc.3 
    L_000c: br.s L_002d
    L_000e: ldloc.2 
    L_000f: ldloc.3 
    L_0010: ldelem.any !!T
    L_0015: stloc.1 
    L_0016: ldloca.s x
    L_0018: ldloc.0 
    L_0019: constrained !!T
    L_001f: callvirt instance int32 [mscorlib]System.IComparable`1<!!T>::CompareTo(!0)
    L_0024: ldc.i4.0 
    L_0025: bge.s L_0029
    L_0027: ldloc.1 
    L_0028: stloc.0 
    L_0029: ldloc.3 
    L_002a: ldc.i4.1 
    L_002b: add 
    L_002c: stloc.3 
    L_002d: ldloc.3 
    L_002e: ldloc.2 
    L_002f: ldlen 
    L_0030: conv.i4 
    L_0031: blt.s L_000e
    L_0033: ldloc.0 
    L_0034: ret 
}

You can see the T (for generics) is there, in full. The JIT (in most CLI implementations, not all) is responsible for figuring out what is necessary; typically all reference-type implementations share an implementation (since all references look the same under the hood), but each value-type implementation gets a separate JIT (as they have different memory layouts).