This is one of those entries that attempts to fill a void in online search for a particular topic. I ramble on for a while to give enough context so that a search engine can match it up in a relevant manner.
I was debugging something the other day, and thought I had come across a heinous bug in the CLR. Turns out, everything was working fine and the bug was in the app.
A program was crashing and it was a managed exception, so I attached to it with VS2008 and dug in. The first thing I noted was that this was a retail build, so my stack was collapsed in a number of places... expected, keep moving. Then, I noted an interesting frame on my stack (this is a contrived example, not the actual thing I saw):
> CanonTest.exe!CanonTest.GenericType<System.__Canon,int>.SomeOperation() + 0x55 bytes
That's weird, what is System.__Canon and what's it doing here? Surely this must be a horrible CLR bug where my method tables are being corrupted! Internet searches seem to be confirming my thoughts. A few others with random __Canon's showing up on the stack do look like bugs. After a bit more reasoning, I come to the conclusion that System.__Canon must be special in some way since it follows the pattern for such things... marked internal, pre-pended with double-underscore.
A few emails later, I had my answer. System.__Canon is the special type that is used to identify "canonical" generic type instantiations. It typically only shows up in release builds, so you don't normally see it on the stack while debugging. So, it's easy to assume something's wrong when you do see it.
If you'll recall, one of the really cool things about the Generics implementation is that it allows for code sharing. Jitted methods can be shared between compatible type instantiations. For instance, the code for SomeGenericType<string> can likely be shared with SomeGenericType<Foo> (where Foo is another reference type. We don't currently share code between value types, so you'll continue to see those on the stack such as in the example). That shared code needs to live somewhere, so we have the concept of a "canonical" generic type instantiation that is identified by __Canon as the type parameter.
Also, in alot of debugger stack representations you'll get the GenericType`2 form rather than expanded form. In that case, you never see __Canon.
For some more info on Generics and code sharing, see Joel Pobar's excellent blog entry on the subject.