Question: Base types of generics

[AnakinRaW]

According to ECMA I.8.7 p. 37 generic parameter types don't have a base type.
However the following code indicates that they have one, at least at runtime.

I'm sure both, the spec and the reflection implementation are correct, but i don't really understand what's happening here. Hope someone can help me.

Cheers

var b = typeof(C<>)
    .GetGenericTypeDefinition()
    .GetGenericArguments()[0].BaseType; // gives System.Object

class C<T> {}

[c-ohle]

@AnakinSklavenwalker It's the base type of the generic type argument. Try this:

    class C<T> { }
    class D<T> where T : struct { }

    static void test()
    {
      //b1: System.Object means ... no constraint for T
      var b1 = typeof(C<>).GetGenericTypeDefinition().GetGenericArguments()[0].BaseType;
      
      //b2: System.ValueType means ... constraint T must struct
      var b2 = typeof(D<>).GetGenericTypeDefinition().GetGenericArguments()[0].BaseType;
      
      //ok, can make a generic type from template ... of for example C<string>       
      var t1 = typeof(C<>).GetGenericTypeDefinition().MakeGenericType(typeof(string));

      // create instance ... new C<string>();
      var t2 = Activator.CreateInstance(t1);

      // cast object t2 to  C<string> t3
      var t3 = t2 as C<string>;
    }    

[AnakinRaW]

Thank for this. I already got this far. And this seems pretty clear to my why it behaves this way.
But for me it's still not clear how this relates to what's written in ECMA.

If i'd had to explain it, i'd say:
"generic argument" and "generic parameter" are two different things. the generic parameter is only defined by the type system. Thus the ECMA types !Index and !!Index do not have a base type as indicated by section I.8.7. At runtime however these generic parameter types don't seem to exists and are "substituted" by a generic argument representation, thus they have a base type.

So if that's a correct assumption, then

• I maybe got confused with Reflection and expected GetGenericTypeDefinition().GetGenericArguments() would give me access to that native generic param type.
• It's unclear to me where, if at all, the rule described by the spec is implemented by CLR or reflection.

The implementation of Type.GetBaseType in reflection explicitly covers the case where the current type is a generic and builds the base type as you demonstrated. However the CLR implementation just throws an ArgumentException CLR GetBaseType.

btw, it's a little hard to express my confusion in words ;)

[c-ohle]

I know what you mean, it's confusing but (for me) it marks a endpoint since the the generic type definition allows recursive constructions eg. C<D<>>. At least I came to that point at writing functions for an expression compiler.
It gets very recursive in this code when eg. Linq expressions are compiled.

[AnakinRaW]

Yeah i know things get nasty, but since i'm working mostly with the ecma spec and only use the runtime's behavior as a too to confirm my understanding of the type system, this got my attentions. I didn't find any explaination for this and i don't trust my own assumption on this matter.