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>，但并没有走得太远。

最后，我确定了一个装饰器模式：

    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 的一些一般信息：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 的 Wrap 中添加向上堆栈。