如何使委托引用方法的特定版本？

Question

I'd like to make a delegate that invokes a specific instance method, unfortunately, it seems that if the method is virtual, the override of the method for the inheriting class will be invoked rather than the base version.

    public class Base{
        public virtual void Method(){
            Console.WriteLine("Base");
        }
    }

    public class Child : Base{
        public override void Method(){
            Console.WriteLine("Child");
        }
    }

If somewhere else in the code I have the following::

var action = Delegate.CreateDelegate(typeof(Action<Base>), typeof(Base).GetMethod("Method")) as Action<Base>;
action(new Child());

The output of this program is Child . I'd really like it to be Base . I've tried the same thing with expression trees and I get the same result, as the IL emitted uses the callvirt method. Is the only way to do something like this really with Reflection.Emit ?

The reason I ask is that I am using a type builder to override behavior of a class. If I were to write the method myself, I could just go base.Method() or whatever, but, some of the method behavior can only be determined dynamically at runtime, as accounting for the many possible cases would be very tedious.

Since i'm creating a class that derives from Base at runtime, if I try to invoke Method() inside the Method() overload I'm making it leads to infinite recursion and stack overflow exceptions. (not so good).

This is for an AOP style project where I'm adding some logic to the methods at runtime. I tag the methods with attributes, I then have a type builder that create methodBuilders feeding the body of the methodbuilder with an expression tree using the CompileToMethod(methodbuilder) http://msdn.microsoft.com/en-us/library/dd728224.aspx , This is a ton easier than reflection.emit, as the logic is non-trivial that I am adding. The goal is than I have a factory spit out a new class that whenever I call Method() it does some logic first before ultimately calling the base implementation.

Answer 1

Maybe you can use such a workaround:

public class Base{
    public virtual void Method(){
        MethodImpl();
    }
    public void MethodImpl(){
        Console.WriteLine("Base");
    }
}

public class Child : Base{
    public override void Method(){
        Console.WriteLine("Child");
    }
}

Now, you can create a delegate representing MethodImpl .

Answer 2

Yes, Reflection.Emit is the only way provided by the .NET framework to implement method overloads. Since the other APIs aren't used when overloading methods, they don't provide any way to chain to the base implementation.

Answer 3

What's suppose to happen here?

class Base { public abstract void Method(); }
class Child {
    public override void Method() {
        Console.WriteLine("Child.Method");
    }
}

Action<Base> magicalAction = // defined somehow
magicalAction(new Child()); // aiya!

You're trying to defeat the point of virtual methods. Why?

Answer 4

Since Reflection.Emit is such a difficult way to build a whole method, I would recommend using Reflection.Emit to create private methods just for calling the base methods. Then you can refer to those methods from your Expression s.