Generics: Accessing New Members, Not Hidden Members

Answer 1

No. The calls generated by the compiler are to the members it knows about at compile-time. That's the members exposed by ObjectA.

Any reason you're not using normal inheritance, with virtual/overridden methods?

Here's another example of the same kind of thing, by the way - the overloaded == operator for strings isn't used, even though T is string in the call to Foo:

using System;

class Test
{
    static bool Foo<T>(T first, T second)
        where T : class
    {
        return first == second;
    }

    static void Main()
    {
        string x = "hello";
        string y = new string(x.ToCharArray());

        Console.WriteLine(Foo(x, y));
    }
}

Answer 2

This may not be an answer to your question, but I don't see the point with your approach (it may be because I only see a simplified example, though).

I would suggest using the following approach:

class ObjectA
{
    public virtual void Invoke()
    {
        // do some work
    }
}

class ObjectB : ObjectA
{
    public override void Invoke()
    {
        // do some other work
    }
}

class GenericNotNeededClass
{  
    public void DoWork(ObjectA item)  
    {  
        item.Invoke();  
    }  
}  


static void Main()  
{  
    GenericNotNeededClass nonGenericClass = new GenericNotNeededClass();  
    ObjectB objectB = new ObjectB();  
    nonGenericClass.DoWork(objectB);
}

I would believe that code does what you are looking for, based on your example code.

Answer 3

You define T to be of type ObjectA for your generic. If Invoke() were virtual it would work the way you are thinking, but because it is not, your generic calls the ObjectA implementation because that is what T is defined to be.

There is no virtual method table entry to point to the ObjectB implementation of Invoke() so this is all the runtime can call. If it were a virtual method there would be a method address in the VMT and it would act like you were thinking that it would.