Question

我有这段代码：

abstract class CommunicationChannel<Client> : IDisposable where Client :  class, IDisposable {
    protected Client client;

    public void Open() {
        try
        {
            client = CreateClient();
        }
        catch (Exception)
        {
            client.Dispose();
            throw;
        }
    }

    public virtual void  Dispose() {
        client.Dispose();
    }

    private Client CreateClient()
    {
        return Activator.CreateInstance<Client>();
    }
}

class Communicator : CommunicationChannel<Client>
{
    // here I have specific methods
    void Method1(args) {
        Open();

        try {
            client.Method1(args);
        }
        catch(Exception) {
            // Cleanup
        }
    }

    // this is getting too verbose already
    void Method2(args) {
        Open();

        try {
            client.Method2(args);
        }
        catch(Exception) {
            // Cleanup
        }
    }

} 

class Client: IDisposable {
    public void Dispose()
    {

    }
}

我希望基类CommunicationChannel能够以某种方式拦截与客户端相关的所有调用，并在将异常传播到派生类CommunicationChannel之前处理异常。基类的泛型参数可以包含不同的方法（在我的示例中，我们只有方法1）

我理想地想要一个解决方案，我不必调用CommunicationChannel.CallMethod（“Method1”，args）。

Answer 1

您可以client私有并强制子类在Func或Action中访问它。然后，您可以在逻辑之前/之后添加您：

abstract class CommunicationChannel<Client> : IDisposable where Client : class, IDisposable
{
    private Client client;

        protected TResult WithClient<TResult>(Func<Client, TResult> f)
        {
            this.Open();
            try
            {
                return f(client);
            }
            catch (Exception)
            {
                //cleanup
            }

            return default(TResult);
        }

    protected void WithClient(Action<Client> act)
    {
        WithClient<object>(c => { act(c); return null; })
    }
}

您的子类可以这样做：

class Communicator : CommunicationChannel<Client> 
{
    bool Method1(args) 
    {
        return WithClient<bool>(c => { return c.Method1(args); });
    }
}

Answer 2

我认为这是使用AOP（面向方面编程）的好例子。

你可以做的是设置一个方面OnEntry，执行Open方法并使用OnException方法捕获异常。

然后你要做的就是用属性

装饰你想要使用那个方面的方法

我用PostSharp演示了我的意思：

public class CommunicationAspect : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        var communicationObject = args.Instance as CommunicationObject;
        communicationObject.Open();
        args.FlowBehavior = FlowBehavior.Continue;
    }

    public override void OnException(MethodExecutionArgs args)
    {
        _logger.log(string.Format("Exception {0} has occured on method {1}", args.Exception, args.Method.Name));
    }
}

然后，使用以下属性修饰您的方法：

class Communicator : CommunicationChannel<Client>
{
  [CommunicationAspect]
  void Method1(args) 
  {
     client.Method1(args);
  }

  [CommunicationAspect]
  void Method2(args)
  {
     client.Method2(args);
  }
}

PostSharp是一个很棒的框架，让它很容易上手，我建议你研究一下。

拦截方法调用泛型类

2 个答案: