How does the C# compiler work with generics?

Question

In C++, the template declarations need to be in a header file (unless you explicitly declare the template type), and I see understand why.

What I don't get is how the C# compiler can handle generics if it doesn't have the .cs file to examine. I doubt it examines the CIL as that would be a processor intensive operation. I know it is able to extract type information from the metadata, but if the code of the generic functions were encoded also, it would be a huge bloat to the executable.

So, again, how does the compiler work with generics?

Yes, I know what templates are in C++. C# generics are not quite the same thing. — phoog, Jan 15 '13 at 17:41
But they accomplish the same thing if you abstract them enough. — , Jan 15 '13 at 17:41
They both allow a class (or struct) with the same name that allows a variety of types. — , Jan 15 '13 at 17:42
@anon but they do that differently. So which part of what they accomplish are you asking about? — phoog, Jan 15 '13 at 17:43
There is a huge difference between .net's generic and C++'s templates: C++ templates do overload resolution at instantiation time, .net generics do that at definition time and require you to specify which interfaces/classes those methods use. — CodesInChaos, Jan 15 '13 at 17:51

score 9 · Answer 1 · answered Jan 15 '13 at 17:45

I guess you're asking about how the C# compiler consumes generic types defined in a referenced assembly, rather than asking about how the C# compiler compiles a .cs file that defines a generic type (since you say "if it doesn't have the .cs file").

Generic types and members are encoded as generic in IL. The closed generic types and members are constructed by the jit compiler at run time. So the trivial answer to your question is "the C# compiler handles generic types by emitting IL that causes the jit compiler to construct them at run time."

And this CLR support for generics means you may invent new constructed types (i.e. the type resulting from a generic type when the type parameters have been specified) at run-time via reflection. — The Dag, Jan 15 '13 at 18:08

score 3 · Answer 2 · edited May 23 '17 at 11:59

C# compiler reads metadata about types from assemblies, no need to look at IL. You can write similar code using reflection to analyze generic types.

C# compiler also have no reason to look inside implementation of methods.

Please check What are the differences between Generics in C# and Java... and Templates in C++? and similar search results for reasons why C# does not need to know implementation of method (unlike C++) - all constraints in C# are known from class/method signature unlike in C++ templates where type just need to match names of methods used inside body.

score 2 · Answer 3 · answered Jan 15 '13 at 18:43

Let me try to clear things up...

Generics are stored as IL including the parameters and constraints in the metadata. Generic types are types as well, which are converted to runtime types at runtime. This is the main difference from C++ where the template types don't exist, but only the derived types; in C# the generic types exist in the DLL, but the derived types do not (until they are created at run-time).

However, there are some things the compiler does do. If you have a List.Add(T) for example, the signature for that in the IL is exactly that. However, if you call it, it resolves the method using List.Add(Foo) as method. E.g. in your IL it will show something like this (when loading a field):

ldfld class [mscorlib]System.List`1<Foo> Bar::variable

Notice that 'Foo' is here and not 'T'.

Also, if you put constraints on the T in your generics definition, they are checked compile-time against the metadata.

At this point I'd like to point out something entirely different but related. C# gains performance by lazy-generating types (in general). This is also very different from C++. You can see this in action if you experiment with static constructors and when they are called.

Something is not clear as I'm reading this (I'm aware this might be another question altogether) -- Is IL changed at run time? Or, were you pointing out that a method's call and definition will look different in the IL? — ryanwebjackson, Sep 21 '17 at 15:32
@ryanwebjackson IL isn't changed; assembler is. If you have a reference type, the code is simply compiled to assembler and used as-is. However, if you have a value type, the assembler code and stack depend on the value type itself - so unlike what happens with reference types, every value type is compiled to a different piece of assembler. If you use a template in C++, you simply insert the type and properties of the type there, and compile it. — atlaste, Sep 21 '17 at 17:02

How does the C# compiler work with generics?

3 Answers3

Linked