5

In Java, this code doesn't work:

public <T> void foo() { print(T.class); } // compile time error

Beacuse the generic type T is erased at runtime. To use T, I must use it as an argument, which will push String.class into stack

public <T> void foo(Class<T> T) { print(T); }
public void bar() { foo(String.class); }

But in C#, I can get type argument at runtime:

public void Foo<T>() { print(typeof(T)); }

How does it work? Does the compiler (or vm) automatically translate void Foo<T>() to void Foo(Type T)?

update:

I disassembled the bytecode and got something like:

ldtoken    !!T
call       System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)

Since ldtoken is an instruction which "Convert metadata token to its runtime representation", it's clear that the runtime type of T is stored as metadata.

I guess each method has it's own "metadata table" (or something like that), so calling Foo<string>() and Foo<object>() will generate two "method handle" and two "metadata table", but share the same machine code. Is it?

yyyy
  • 593
  • 2
  • 10
  • https://stackoverflow.com/questions/355060/c-sharp-vs-java-generics explains that... (also you've likely already seen it in your research) – Alexei Levenkov Feb 10 '19 at 07:24
  • Java imposes a generic type system on a runtime which is not aware of generics. That's not the case for C#. In C#, the runtime and the language were both written to support generics. – Eric Lippert Feb 10 '19 at 19:34

2 Answers2

5

Does the compiler (or vm) automatically translate void Foo() to void Foo(Type T)?

No it doesn't. The body for generic methods is generated at runtime, on the fly. So, for example, when you supply T as int, this method is generated:

public void Foo<int>() { print(typeof(int)); }

This happens every time you pass a different type. But if you use the same type again the CLR will cache the previously generated method and execute it, instead of generating a new one.

Selman Genç
  • 100,147
  • 13
  • 119
  • 184
  • 3
    Your last point isn't quite right. The CLR generates new run-time methods for each value-type, but only one for all reference types. – Enigmativity Feb 10 '19 at 06:06
0

In .NET, generics are not erased. The CLR implements generics all the way down to the byte code.

nilekirk
  • 2,353
  • 1
  • 8
  • 9