Способы обертывания с различными сигнатурами, пред-и после-вызов

Question

Как избежать пары повторяющихся строк до и после вызова в примере ниже? Подробности: Это скомпилированный макет, что является реальным большим кодом. Как правило, это слой прокси-классов, содержащий сервисные клиенты с различными API-интерфейсами. Повторяющаяся часть - это до и после вызова для каждого метода каждого клиента. К сожалению, для всех возможных методов не существует единой подписи, для пред- и пост-частей требуется указатель на канал и контекст клиента. Можно ли применить нечто передовое, например AOP, Generics, Delegates, Attributes и т. Д.? Спасибо

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

Если вы можете использовать общий базовый класс, вы можете легко использовать герметичный публичный метод, который делает вызов и защищенный абстрактный метод, который делает логику, например,

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]); 
    } 
} 

Вы можете достичь подобных результатов функционально, объявив InvocationHandler в своем классе программа, которая берет действие:

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)); 
    } 
}