Question

我想要修改应用责任链（CoR）模式的代码，但如果我有许多后继者，我对性能有疑问。首先，这是没有CoR的代码：

public class OperationService
{
    public Response Exec_Operation_1(Data data)
    {
        Operation_1 op = new Operation_1();
        return op.ExecOperation();
    }

    public Response Exec_Operation_2(Data data)
    {
        Operation_2 op = new Operation_2();
        return op.ExecOperation();
    }
}
public class Operation_1
{
    private Data _data;
    public Operation_1(Data data)
    {
        this._data = data;
    }
    public Response ExecOperation()
    {
        //process data. So much code. Many instantiations.
        //Many references to other assemblies.
        //serialize/deserialize xml. Call webservices. 
        return new Response();
    }
}
//Operation_2 class seems like Operation_1 class...

嗯，确实有很多操作类：Operation_3，.... Operation_N，可能介于11到15个类之间，但此时只有Operation_1和Operation_2。如果我想添加Operation_3，那么我必须更新OperationService类，添加一个新方法：Exec_Operation_3（数据数据）。

我看到所有方法都返回相同的类型（Response）并作为参数接收相同的类型（Data），Operation_1和Operation_N的方法也会有相同的签名，所以我想我可以这样重写代码：（解决方案1）

public class OperationService
{
    public Response Exec_Operation(Data data)
    {
        OperationCaller caller = new OperationCaller();
        return caller.ExecOperation(data);
    }
}
public class OperationCaller
{
    public Response ExecOperation(Data data)
    {
        IOperation unknownOperation = new UnknownOperation();
        IOperation operation_2 = new Operation_2(unknownOperation);
        IOperation operation_1 = new Operation_1(operation_2);        
        return operation_1.ExecOperation(data);
    }
}
public interface IOperation
{
    bool CanExecute(Data data);
    Response ExecOperation(Data data);
}
public class Operation_1:IOperation
{
    private IOperation _succesor;
    public Operation_1(IOperation succesor)
    {
        this._succesor = succesor;
    }
    public CanExecute(Data data)
    {
        return data.OperationType.equals("1");
    }
    public Response ExecOperation(Data data)
    {
        if(this.CanExecute)
        {
            //process data. So much code. Many instantiations.
            //Many references to other assemblies.
            //serialize/deserialize xml. Call webservices.
            return new Response();
        }
        else
        {
            return this._succesor.ExecOperation(data);
        }
    }
}
//Other IOperation implementations seems like this Operation_1.

如果您看到我正在应用CoR模式，这样我在添加新的Operation_X类时就不必修改OperationService类，我只需要更新OperationCaller类。

但是在这个解决方案中，我只修改类Operation_1（和Operation_2，...，Operation_N），但这个类有很多代码，读取有点困难所以我认为它是＆＃39 ;最好创建另一个类来使用CoR并在该类中创建Operation_1，..，Operation_N的实例，如下所示:(解决方案2）

public class OperationCaller
{
    public Response ExecOperation(Data data)
    {
        IOperation unknownOperation = new CoRUnknownOperation();
        IOperation operation_2 = new CoROperation_2(unknownOperation);
        IOperation operation_1 = new CoROperation_1(operation_2);        
        return operation_1.ExecOperation(data);
    }
}
public interface IOperation
{
    bool CanExecute(Data data);
    Response ExecOperation(Data data);
}
public class CoROperation_1:IOperation
{
    private IOperation _succesor;
    public Operation_1(IOperation succesor)
    {
        this._succesor = succesor;
    }
    public CanExecute(Data data)
    {
        return data.OperationType.equals("1");
    }
    public Response ExecOperation(Data data)
    {
        return (this.CanExecute) ? new Operation_1().ExecOperation(data);
                                 : this._succesor.ExecOperation(data);
    }
}

在最后一个解决方案我没有修改 Operation_1，我只创建了一个层来解耦OperationService（它的目标）。

但我认为Operation_1实例 - 在最后一个解决方案 - 或IOperation实例 - 在第一个解决方案中 - 是一个有点重的对象而且OperationCaller创建了很多它们所以我对此有疑问，我不知道如果此实施/解决方案存在性能问题。

你怎么看？在这种情况下，我会使用CoR遇到性能问题吗？如果没有，第一个解决方案（解决方案1）或最后一个解决方案（解决方案2）的解决方案更好？

Answer 1

在这种情况下，我会使用CoR遇到性能问题吗？

是的，使用责任链时存在性能问题：

为每次数据调用重新创建链中的每个操作
操作查找时间与操作链长度成比例

这些性能问题来自于IOperation违反单一责任原则并将操作查找算法CanExecute与操作执行算法ExecOperation相结合的事实。每次要进行操作查找时，都必须创建执行算法。

在解决方案2中，您使用代理类Operation将CoROperation类中包含的执行算法与查找算法分离，但这会带来复杂性。

在示例中，有一个清晰的鉴别符OperationType，可用于操作查找。

解决方案是按Func(of Data, IOperation)制作一个操作构造函数的字典OperationType。

dim Dictionary as new Dictionary(of String, Func(of Data, IOperation))

Dictionary提供查找算法。

操作构造函数确定如何获取操作，并提供指定操作生命周期的功能。

例如，

LightOperation1与数据无关且不重，
HeavyOperation2也是数据无关但很重，应该在需要时创建，
InjectedOperation3也是数据无关且依赖注入
DataDependentOpartion4取决于数据，必须为新数据重新创建
操作5将实际执行调用委托给某个服务

然后

class OperationCaller
    private readonly OperationDictionary as IDictionary(of String, Func(of Data, IOperation))

    public sub new(InjectedOperation3 as IOperation, OperationService as IOperationService)

        dim LightOperation1 as new LightOperation1
        dim HeavyOperation2 as new Lazy(of HeavyOperation2)(function() new HeavyOperation2)

        dim Dictionary as new Dictionary(of String, Func(of Data, IOperation)) from {
            {"1", function(Data) LightOperation1},
            {"2", function(Data) HeavyOperation2.Value},
            {"3", function(Data) InjectedOperation3},
            {"4", function(Data) new DataDependentOperation4(Data)},
            {"5", function(Data) new DelegateOperation(addressof OperationService.Exec_Operation_5)}
        }

        me.OperationDictionary = Dictionary
    end sub

    public function ExecOperation(Data as Data) as Response
        return OperationDictionary(Data.OperationType)(Data).ExecOperation(Data)
    end function
end class

ExecOperation类的方法OperationCaller通过字典查找适当的操作构造函数，获取并执行操作。

优点：

由于字典
控制每个操作生命周期的非常灵活的方法提供了缓存操作和/或推迟繁重操作创建的机制

缺点：

Lambda函数
如果没有明确的操作鉴别器，则必须使用模式匹配而不是字典

责任链绩效

1 个答案: