C# intercepting methods and injecting method calls

Question

What I have is:

class ABC
{
    public void MethodA()
    {
        Console.WriteLine("In method A");
    }
    public void MethodB()
    {
        Console.WriteLine("In method B");
    }
    public void MethodC()
    {
        Console.WriteLine("In method C");
    }
}

class PQR
{
    public void MethodP()
    {
        Console.WriteLine("In method P");
    }
    public void MethodQ()
    {
        Console.WriteLine("In method Q");
    }
    public void MethodR()
    {
        Console.WriteLine("In method R");
    }
}

What I want to achieve is:

Call (or maybe inject using any DI frameworks)

MethodP() in MethodA(), MethodQ() in MethodB(), MethodR() in MethodC(),

But without extending Class PQR on Class ABC or vice versa. Or without modifying Class ABC, I can Modify Class PQR. I did checked some of the existing DI frameworks like Prism, Autofac, Unity but to use them I have to modify Class ABC (Adding some attributes, extending to some interfaces etc.), which I don't want to do.

How can I achieve this?

UPDATE 1: Class ABC and class PQR don't have any super class/interface in common.

Answer 1

The general design pattern for this is the Decorator Pattern. You can do this by defining an interface IABC for ABC:

interface IAbc {
    void MethodA();
    void MethodB();
    void MethodC();
}

Now you can define a decorator for IABC that is able to 'intercept' calls to ABC and calls PQR before calling ABC:

class AbcToPqrDecorator : IAbc
{
    private readonly PQR pqr;
    private readonly IAbc decorated;

    public AbcToPqrDecorator(PQR pqr, IAbc decorated) {
        this.pqr = pqr;
        this.decorated = decorated;
    }

    public void MethodA() {
        pqr.MethodP();
        decorated.MethodA();
    }
    public void MethodB() {
        pqr.MethodQ();
        decorated.MethodB();
    }

    public void MethodC() {
        pqr.MethodR();
        decorated.MethodC();
    }
}

You can create the object graph as follows:

IAbc abc = new AbcToPqrDecorator(new PQR(), new ABC());

Important note: in case you find the use of decorators leads to a lot of overhead (because you are required to define many decorator implementations with the same behavior but for different interfaces), this is an indication that you are violating SOLID and missing a common abstraction. Your comment indicates that this is indeed the case:

I have 50+ such classes like ABC.

As an example of how to design your system, this article describes how you can design a part of your system in such way that it becomes trivial to wrap operations like MethodA(), MethodB() and MethodC() with one generic decorator that only needs to be defined once.

Answer 2

One method how to handle this kind of stuff is Castle.DynamicProxy. There are drawbacks - if you don't implement class instead of interface, methods needs to be virtual in order for interception to work:

//Install-Package Castle.DynamicProxy

public class Interceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.Out.WriteLine("Intercepting: " + invocation.Method.Name);
        invocation.Proceed();
    }
}

public class ABC
{
    public virtual void MethodA()
    {
        Console.WriteLine("In method A");
    }
    public void MethodB()
    {
        Console.WriteLine("In method B");
    }
}

Usage:

var generator = new ProxyGenerator();
var abc = generator.CreateClassProxy<ABC>(new Interceptor());
// "Intercepting: MethodA"
// "In method A"
abc.MethodA();
// oops - not virtual method - no interception
// "In method B"
abc.MethodB();

PostSharp is much more powerful, and the AOP magic happens after the build (so it is more performant), unfortunatelly it is not free.

Answer 3

I am working on NConcern .NET AOP Framework, a new open source AOP framework working at runtime whithout any factory/proxy pattern and reflection performance cost. It seems to be able to handle what you need.

Please take a look on.

public class MonkeyPatch : IAspect
{
    static public void Patch(MethodInfo oldMethod, MethodInfo newMethod)
    {
        //update monkey patch dictionary
        MonkeyPatch.m_Dictionary[oldMethod] = newMethod;

        //release previous monkey patch for target method.
        Aspect.Release<MonkeyPatch>(oldMethod);

        //weave monkey patch for target method.
        Aspect.Weave<MonkeyPatch>(oldMethod);
    }

    static private Dictionary<MethodInfo, MethodInfo> m_Dictionary = new Dictionary<MethodInfo, MethodInfo>();

    public IEnumerable<IAdvice> Advise(MethodInfo method)
    {
        if (MonkeyPatch.m_Dictionary.ContainsKey(_Method))
        {
            yield return Advice(MonkeyPatch.m_Dictionary[_Method]);
        }
    }
}

Usage

static public void main(string[] args)
{
    //MonkeyPatch.Patch(typeof(ABC).GetMethod("A"), typeof(PQR).GetMethod("P"));
    MonkeyPatch.Patch(Metadata<ABC>.Method(_ABC => _ABC.A()), Metadata<PQR>.Method(_PQR=> _PQR.P()));

    //MonkeyPatch.Patch(typeof(ABC).GetMethod("B"), typeof(PQR).GetMethod("Q"));
    MonkeyPatch.Patch(Metadata<ABC>.Method(_ABC => _ABC.B()), Metadata<PQR>.Method(_PQR=> _PQR.Q()));

    //MonkeyPatch.Patch(typeof(ABC).GetMethod("C"), typeof(PQR).GetMethod("R"));
    MonkeyPatch.Patch(Metadata<ABC>.Method(_ABC => _ABC.C()), Metadata<PQR>.Method(_PQR=> _PQR.R())); 
}

Answer 4

I really see your PQR class as holding an event instead of methods, since you want to inject a method inside another method:

class PQR
{
    public event EventHandler MethodP;
    public event EventHandler MethodQ;
    public event EventHandler MethodR;

    public PQR()
    {
        MethodP += delegate { MethodP1(); };
        MethodQ += delegate { MethodQ1(); };
        MethodR += delegate { MethodR1(); };
    }

    private void MethodP1()
    {
        Console.WriteLine("In method P");
    }
    private void MethodQ1()
    {
        Console.WriteLine("In method Q");
    }
    private void MethodR1()
    {
        Console.WriteLine("In method R");
    }
}

then you can simply add methods to the events:

var abc =  new ABC();
var pqr = new PQR();
pqr.MethodP += delegate { abc.MethodA(); };
pqr.MethodQ += delegate { abc.MethodB(); };
pqr.MethodR += delegate { abc.MethodC(); };

And this way you can let your ABC class untouched.