Question

How to avoid a pair of repetitive lines before and after invocations in sample below ?
Details: This is compileable mock of what is real larger code. Generally it is a layer of proxy classes containing service clients with variety of APIs. The repetitive part is pre- and post- invocation for every method of every client. Unfortunately there is no single signature for all possible methods, the pre- and post- parts need a pointer to client’s channel and context.
Is it possible to apply something advanced like AOP, Generics, Delegates, Attributes etc. ? Thank you

using System;

namespace ConsoleApplication
{
class ClassServiceClient: IDisposable
{ 
    public Object channel()
    {
        return "something";
    }

    public Object context()
    {
        return "something other";
    }
}

class ClassA : ClassServiceClient
{
    public Object methodA()
    {
        return "something other";
    }
}

class ClassB : ClassServiceClient
{
    public void methodB(string param)
    {
        return;
    }
}

class ClassAProxy 
{
    public Object methodA()
    {
        using (ClassA client = new ClassA())         
        {
            Program.preparation(client.channel());   //<---- repetitive part
            Object result = client.methodA();
            Program.postinvocation(client.context());//<---- repetitive part
            return result;
        }
    }
}

class ClassBProxy
{
    public void methodB(string param)
    {
        using (ClassB client = new ClassB())
        {
            Program.preparation(client.channel());   //<---- repetitive part
            client.methodB(param);
            Program.postinvocation(client.context());//<---- repetitive part
            return;
        }
    }
}


class Program
{
    public static void preparation(Object channel)
    {
        // Do something with channel
    }

    public static void postinvocation(Object context)
    {
        // Do something with context
    }

    static void Main(string[] args)
    {

    }
}
}

Answer 1

If you can use a common base class, you can easily use a public sealed method that does the invocation and a protected abstract method that does the logic, e.g.

class ProxyBase{
    public void Method(params object[] args){
        PreConditions();
        Invoke(args);               
        PostConditions();
    }

    protected abstract void Invoke(object[] args);
}

class ClassAProxy{
    protected override void Invoke(object[] args){
        client.Method(args[0]);
    }
}

You can achieve similar results functionally by declaring a InvocationHandler in your Program class that takes an action:

class Program{
    public static void Invoke(object[] args, Action action){
        PreConditions();
        action();
        PostConditions();
    }
}

class ClassAProxy{
    public void MethodA(int i){
        Program.Invoke(() => client.Something(i));
    }
}