1

我对责任链模式有疑问。所有处理程序都实现这个类：

/// <summary>
/// Chain of Responsibility pattern
/// </summary>
abstract public class ChainHandler
{
    protected LogWrapper Log;
    protected ChainHandler successor;

    /// <summary>
    /// SetSuccessor
    /// </summary>
    private void SetSuccessor(ChainHandler successor)
    {
       this.successor = successor;
    }

    protected oAPI NotImplemented
    {
        get { return new oAPI(HTTPCodes.NotImplemented); }
    }

    /// <summary>
    /// Set Successor to the end of chain
    /// </summary>
    /// <param name="successor">Handler</param>
    public void Add(ChainHandler successor)
    {
        if (this.successor == null) SetSuccessor(successor);
        else
        {
            this.successor.Add(successor);
        }
    }
    protected oAPI ReferToSuccessor (iAPI request)
    {
        if (successor != null) return successor.HandleRequest(request);
        return NotImplemented;
    }
    /// <summary>
    /// output API builder
    /// </summary>
    /// <param name="code">HTTP code</param>
    /// <returns></returns>
    protected oAPI RB(HTTPCodes code, string messsage = null, string data = null, bool hasError = false)
    {
        return new oAPI(Shared.User, code, message) { Data = data, HasError = hasError };
    }
    /// <summary>
    /// Serializer (JSON)
    /// </summary>
    public Func<object, string> Serializer { get; set; }
    /// <summary>
    /// Handle request
    /// </summary>
    /// <param name="request">request</param>
    /// <returns>result</returns>
    public abstract oAPI HandleRequest(iAPI request);
}

然后我实施DocHandler

public class DocHandler:ChainHandler
    {
     public DocChain()
     {
      Log = new LogWrapper(this);
     }
     public override oAPI HandleRequest(iAPI request)
     {
      switch (request.Comand)
      {
       case iAPI.Target.GetModel:
        return GetModel(request.DocID);
      }
      return ReferToSuccessor(request);
      }
 private Doc GetDoc(int id)
    {
     Log.Debug("get document by id: " + id);
     using (var unit = UnitOfWork.Create())
     {
      var repository = unit.GetRepository<Doc>();
      Doc doc = repository.Get(id);
      if (doc == null)
      {
       Log.Error("Document not found");
       throw new DocumentNotFoundException();
      }
      return doc;
     }
    }

 public oAPI GetModel(int DocId)
      {
       var Model = GetDoc();
       return RB(HTTPCodes.OK, data: Serializer(
       Model));
       }
}

和CloudHandler

 public class CloudHandler:ChainHandler
    {
        private IDAVService _service;
        private string RemoteRepository;
        public CloudChain(IDAVService service)
        {
            Log=new LogWrapper(this);
            _service=service;
        }

        public override oAPI HandleRequest(iAPI request)
        {
            switch (request.Comand)
                    {
                    case iAPI.Target.UploadModel:
                    return Upload(request.DocID,request.VersionID);
                    case iAPI.Target.DownloadModel:
                    return Download(request.VersionID, request.DocID);
                    }
            return ReferToSuccessor(request);
        }
        public oAPI Upload(int DocID,int VersionID)
        {
            // Need to get model from DocHandler
            var model = ???
            service.Upload(model);
            return RB(HTTPCodes.OK);
        }
        public oAPI Download(int DocID,int VersionID)
        {
            // Need to get model from DocHandler
            var model = ???
            service.Download(model);
            return RB(HTTPCodes.OK);
        }
    }

我的问题是找到在处理程序之间共享方法和属性的最佳方式。现在我使用静态类 SharedComponents，每个处理程序都委托自己的方法。

public static class SharedComponents
    {
        public static Func<int, Doc> GetDoc;
    }

在 DocHandler 中，我委托方法SharedComponents.GetDoc = this.GetDoc;，然后在 CloudHandler 中使用它var Model = SharedComponents.GetDoc(docid)。这是将委托写入数百个共享方法的意大利面。

但是我是如何测试的呢？我将必须初始化所有处理程序（因为A使用方法B和B可能使用方法C等）以在一个处理程序中测试一种方法。恐怖！

我尝试将共享方法设置为静态以使用 like var Model = DocHandler .GetDoc(docid)。但是这个解决方案打破了依赖倒置原则。如果某些共享方法使用上下文（如sessionin UnitOfWork），我需要在测试中再次初始化所有处理程序！

4

1 回答 1

2

应用责任链模式的主要目的之一是让一些步骤相互独立。目标是能够更改步骤顺序或添加新步骤，而无需更改现有步骤。

在您的方法中，即使您在共享类上使用委托，也会引入来自CloudHandlerto的强依赖关系，DocHandler因为它只有在设置委托时才能运行。

为了解决这个问题，我建议从处理程序中提取共享方法，并将它们移动到一个或多个具有虚拟方法或接口的辅助类中。不是在处理程序中创建类的实例，而是在构造期间将所需的实例注入处理程序。您提到了数百种共享方法。以一种好的方式对方法进行分组很重要，这样您就没有太多的帮助类/接口，并且您不必将太多的注入到特定的 Handler 类中。

在您的示例中，您将为 Docs 创建以下帮助程序类：

internal class DocHelper
{
    internal virtual Doc GetDoc(int docId) 
    { 
        // ...
    }

    // Other methods as required
}

DocHandler 和 CloudHandler 在它们的构造函数中获取一个实例，并使用这个实例来获取文档，例如：

public class DocHandler : ChainHandler
{
    private readonly DocHelper docHelper; 

    public DocHandler(DocHelper docHelper)
    {
        Log = new LogWrapper(this); 
        this.docHelper = docHelper;
    }
    // ...
    public oAPI GetModel(int DocId)
    {
        var Model = docHelper.GetDoc();
        return RB(HTTPCodes.OK, data: Serializer(
        Model));
    }
    // ...
}

这种方法使您能够在测试处理程序时提供模拟帮助程序类。

于 2015-11-26T09:29:01.760 回答