93

In many MSIL listings, I have observed the following:

System.Nullable`1<!0> etc ...

or

class !0 etc ...

What's the meaning of !0 in these circumstances?

Force444
  • 3,321
  • 9
  • 39
  • 77
Dragno
  • 3,027
  • 1
  • 27
  • 41

2 Answers2

124

This is quirk of the decompiler you use to look at a .NET assembly. It is the behavior of ildasm.exe, other ones like Reflector or ILSpy get this right. The Microsoft programmer who wrote it took a shortcut, they generated a string from the IL that just displays the type argument the way it is encoded, without writing the extra code to lookup the type argument name in the metadata.

You need to read !n as the n-th type argument of the generic type. Where !0 means "first type argument", !1 means "second type argument", etcetera. For Nullable<>, you know that '!0` means 'T' from the MSDN article.

You may also encounter something like !!T. Two exclamation marks indicate a type argument for a generic method. This time, ildasm.exe does look up the type argument name instead of using !!0. Why the programmer took the shortcut on generic types but not on generic methods is hard to reverse-engineer. Ildasm is a pretty quirky program and is written in a C++ coding style that's very different from other C++ code in .NET. Not as disciplined, non-zero odds that this was an intern's assignment :)

The `1 suffix on "Nullable" is a normal encoding for generic type names, it indicates the generic type has one type argument. In other words, for Nullable<> you'll never see !1 being used.

So simply read !0 as "T". Or use a better decompiler.

Hans Passant
  • 922,412
  • 146
  • 1,693
  • 2,536
35

That is a generic type parameter.

They are positional.

Decompile some generic code to see how they are used (compare IL vs C#).

leppie
  • 115,091
  • 17
  • 196
  • 297
  • 5
    If I use TryRoslyn I don't get it... http://goo.gl/ZZKE38 I get `!T` and `!!T`, depending if the generic parameter is of the containing class or of the method... The same if I use ildasm – xanatos Jul 22 '15 at 12:17
  • @xanatos Not always. I also see code like `ldfld class System.Collections.Generic.Dictionary``2<!0, !1> valuetype System.Collections.Generic.Dictionary``2/Enumerator<!TKey, !TValue>::dictionary` or `call instance void class System.Collections.Generic.Dictionary``2<!TKey, !TValue>::Insert(!0, !1, bool)`. The raw IL only uses the positional argument anyway, though - the `!TKey` is already an attempt to make the IL more readable. Maybe it doesn't always work well? The ECMA spec always uses the positional `!0`/`!00` as well. – Luaan Jul 22 '15 at 14:29