C#: Элегантный способ обертывания вызовов методов

Question

Извинения за довольно неоднозначное название, но то, что я пытаюсь достичь, возможно, лучше указано в коде.

У меня есть клиент WCF. Когда я вызываю методы, я хотел бы объединить каждый вызов в некоторый код обработки ошибок. Таким образом, вместо того, чтобы непосредственно разоблачая методы, я создал следующую вспомогательную функцию на клиентском классе:

public T HandleServiceCall<T>(Func<IApplicationService, T> serviceMethod) 
    { 
     try 
     { 
      return serviceMethod(decorator); 
     } 
     [...] 
    } 

И код клиента использует его как это:

service.HandleServiceCall(channel => channel.Ping("Hello")); 

и призыв к Ping получает красиво завернутый в некоторую логику, которая будет пытаться обрабатывать любые ошибки.

Это отлично работает, за исключением того, что у меня теперь есть требование узнать, какие методы фактически вызываются в службе. Первоначально я надеялся просто осмотреть Func<IApplicationService, T>, используя деревья выражений, но не очень далеко.

Наконец, я остановился на шаблон Decorator:

public T HandleServiceCall<T>(Func<IApplicationService, T> serviceMethod) 
    { 
     var decorator = new ServiceCallDecorator(client.ServiceChannel); 
     try 
     { 
      return serviceMethod(decorator); 
     } 
     [...] 
     finally 
     { 
      if (decorator.PingWasCalled) 
      { 
       Console.Writeline("I know that Ping was called") 
      } 
     } 
    } 

И сам декоратор:

private class ServiceCallDecorator : IApplicationService 
    { 
     private readonly IApplicationService service; 

     public ServiceCallDecorator(IApplicationService service) 
     { 
      this.service = service; 
      this.PingWasCalled = new Nullable<bool>(); 
     } 

     public bool? PingWasCalled 
     { 
      get; 
      private set; 
     } 

     public ServiceResponse<bool> Ping(string message) 
     { 
      PingWasCalled = true; 
      return service.Ping(message); 
     } 
    } 

Это действительно неуклюжим и довольно много кода. Есть ли более элегантный способ сделать это?

Answer 1

Вы можете использовать выражение, а затем осмотреть тело.

Что-то вроде

public T HandleServiceCall<T>(Expression<Func<IApplicationService, T>> serviceMethod)  
{   
    try   
    {   
     var func = serviceMethod.Compile(); 
     string body = serviceMethod.Body.ToString(); 
     return func(new ConcreteAppService()); 
    }   
    catch(Exception ex) 
    { 
     ...  
       } 
} 

Answer 2

Считаете ли вы использование аспектно-ориентированного подхода? Это похоже на то, что вам нужно.

Функциональность обертывания и другие функции «мета-метода» могут быть записаны как «ортогональные» аспекты того, что делают ваши методы serviceMethods.

Некоторые общие сведения о АОП: AOP in wikipedia

И потенциальное решение с контейнером: AOP with Windsor Castle

Answer 3

Вот краткий пример использования дерева выражений:

public T HandleServiceCall<T>(Expression<Func<T>> serviceMethod) 
{ 
    try 
    { 
     return serviceMethod(); 
    } 
    finally 
    { 
     var serviceMethodInfo = ((MethodCallExpression)serviceMethod.Body).Method; 
     Console.WriteLine("The '{0}' service method was called", serviceMethodInfo.Name); 
    } 
} 

Обратите внимание, что этот пример предполагает, что выражение serviceMethod всегда содержит вызов метода.

Связанные ресурсы:

• Expression Class
• MethodCallExpression Class

Answer 4

Да, я считаю, что ваш код переваренные.

С точки зрения упаковки вашего кода для общего безопасного использования прокси, посмотрите here для приятной реализации. С его помощью легко:

using (var client = new Proxy().Wrap()) { 
client.BaseObject.SomeMethod(); 
} 

Теперь вы должны получить доступ к имени метода - для этого просто использовать Environment.StackTrace. Вам нужно добавить ходьбу в стек в Marc Gravell's Wrap.