Question

我有一个类，我必须重复多个步骤才能完成下面的过程，这只是一个伪代码来演示我在问什么。基本上每种方法都需要另外一种方法来做某事，所以一些方法一个接一个地执行以获得所需的结果，但不知何故我不喜欢这样，有没有另一种方法来实现这个可能是使用设计模式？我已经看到了责任链，但这并不适合我，因为我没有不同类型的处理器。

由于

class Processor
{
    void Process()
    {
        var credentials = GetCredentialsFromDb();

        var result = ProcessData(credentials);
    }

    string GetCredentialsFromDb()
    {
        return "user";
    }

    string ProcessData(string credentials)
    {
        return ExtractData();
    }

    string ExtractData()
    {
        return ParseData();
    }

    string ParseData()
    {
        return ValidateData(data);
    }

    string ValidateData(string data)
    {
        return "validatedData";
    }
}

Answer 1

您可能需要构建器模式 - http://en.wikipedia.org/wiki/Builder_pattern

基本上builder初始化你的对象并包含所有的逻辑，每个逻辑都使用不同的方法来获取所需的信息，以“建立”最终结果。

然后你要实现一个总是按顺序调用它们的director。

public static void main() {
    var builder = new ProcessorBuilder();
    ProcessorDirector director = new ProcessorDirector();
    director.Build();
    Console.WriteLine(builder.Processor);
}

class ProcessorDirector { //I tell processor builders how to build processors!
    ProcessorBuilder _builder {get;private set;}
    public ProcessorDirector(ProcessorBuilder builder) {
        _builder = builder;
    }
    public void Build() {
        var credentials = _builder.GetCredentialsFromDB();
        var data = _builder.ProcessData(credentials);
        var isDataValid = _builder.ValidateData();
        if(isDataValid) {
             _builder.ParseData();
        }
    }
}
class ProcessorBuilder
{
    public string Processor {get;set;}
    void ProcessorBuilder()
    {
        //if you change your end result object into a non-value type, you'd initialize it here.
    }
    public string GetCredentialsFromDb()
    {
        return "user";
    }
    string ProcessData(string credentials)
    {
        //process
        //builder should be stateless, so return data
    }
    public string ParseData()
    {
        //parse
    }
    public string ValidateData()
    {
        //validate
    }
}

Answer 2

当你的每个方法调用都包含在后续的方法调用中时，我会说装饰器模式可以满足你的需求。

如果这很重要，这将允许您通过仅接受要包装在其他类型中的某些类型来指定堆栈的构建方式。

用于在类中执行依赖方法的设计模式

2 个答案: