具有不同输入参数的工人的C＃设计模式

我不确定哪种设计模式可以帮助我解决此问题。

我有一个类“ Coordinator”，该类确定应使用哪种Worker类-不必知道那里有所有不同类型的Worker-它仅调用WorkerFactory并根据通用IWorker接口起作用。

然后，它将适当的Worker设置为工作并返回其“ DoWork”方法的结果。

到目前为止还不错。我们对新的Worker类有一个新的要求，即“ WorkerB”，它需要额外的信息量，即额外的输入参数，才能使其工作。

就像我们需要一个带有额外输入参数的DoWork方法重载...但是所有现有的Workers都必须实现该方法-这似乎是错误的，因为这些Workers确实不需要该方法。

我该如何重构，以使协调器不知道正在使用哪个工作人员，并且仍然允许每个工作人员获取完成其工作所需的信息，但没有任何工作人员执行不需要的信息？

已经有很多现有的工人。

我不想更改任何现有的具体Workers来适应新WorkerB类的要求。

我以为Decorator模式在这里会很好，但是我之前没有看到任何Decorator用相同的方法但参数不同来装饰对象...

代码情况：

public class Coordinator
{
    public string GetWorkerResult(string workerName, int a, List<int> b, string c)
    {
        var workerFactor = new WorkerFactory();
        var worker = workerFactor.GetWorker(workerName);

        if(worker!=null)
            return worker.DoWork(a, b);
        else
            return string.Empty;
    }
}

public class WorkerFactory
{
    public IWorker GetWorker(string workerName)
    {
        switch (workerName)
        {
            case "WorkerA":
                return new ConcreteWorkerA();
            case "WorkerB":
                return new ConcreteWorkerB();
            default:
                return null;
        }
    }
}

public interface IWorker
{
    string DoWork(int a, List<int> b);
}

public class ConcreteWorkerA : IWorker
{
    public string DoWork(int a, List<int> b)
    {
        // does the required work
        return "some A worker result";
    }
}

public class ConcreteWorkerB : IWorker
{
    public string DoWork(int a, List<int> b, string c)
    {
        // does some different work based on the value of 'c'
        return "some B worker result";
    }

    public string DoWork(int a, List<int> b)
    {
        // this method isn't really relevant to WorkerB as it is missing variable 'c'
        return "some B worker result";
    }    
}

您将需要对参数进行一般化，以使它们适合于具有基本接口和可变数量的字段或属性的单个参数。有点像这样：

public interface IArgs
{
    //Can be empty
}

public interface IWorker
{
    string DoWork(IArgs args);
}

public class ConcreteArgsA : IArgs
{
    public int a;
    public List<int> b;
}

public class ConcreteArgsB : IArgs
{
    public int a;
    public List<int> b;
    public string c;
}

public class ConcreteWorkerA : IWorker
{
    public string DoWork(IArgs args)
    {
        var ConcreteArgs = args as ConcreteArgsA;
        if (args == null) throw new ArgumentException();
        return "some A worker result";
    }
}

public class ConcreteWorkerB : IWorker
{
    public string DoWork(IArgs args)
    {
        var ConcreteArgs = args as ConcreteArgsB;
        if (args == null) throw new ArgumentException();
        return "some B worker result";
    }
} 

请注意null检查...因为您的系统是灵活的且后期绑定的，所以它也不是安全的类型，因此您将需要检查强制类型转换以确保传递的参数有效。

如果您确实不想为每种可能的参数组合都创建具体对象，则可以使用元组（这不是我的首选）。

public string GetWorkerResult(string workerName, object args)
{
    var workerFactor = new WorkerFactory();
    var worker = workerFactor.GetWorker(workerName);

    if(worker!=null)
        return worker.DoWork(args);
    else
        return string.Empty;
}

//Sample call
var args = new Tuple<int, List<int>, string>(1234, 
                                             new List<int>(){1,2}, 
                                             "A string");    
GetWorkerResult("MyWorkerName", args);

我已经基于@Dunk的评论重新设计了解决方案：

...您已经知道创建IWorker实例之前需要的所有参数。因此，您应该将那些参数传递给构造函数而不是DoWork方法。IOW，请使用您的工厂类。隐藏构造实例的细节几乎是工厂类存在的主要原因。

因此，我已经将创建IWorker所需的所有可能参数转移到IWorerFactory.GetWorker方法中，然后每个工作人员已经拥有了所需的参数，并且协调器可以只调用worker.DoWork（）;。

    public interface IWorkerFactory
    {
        IWorker GetWorker(string workerName, int a, List<int> b, string c);
    }

    public class WorkerFactory : IWorkerFactory
    {
        public IWorker GetWorker(string workerName, int a, List<int> b, string c)
        {
            switch (workerName)
            {
                case "WorkerA":
                    return new ConcreteWorkerA(a, b);
                case "WorkerB":
                    return new ConcreteWorkerB(a, b, c);
                default:
                    return null;
            }
        }
    }

    public class Coordinator
    {
        private readonly IWorkerFactory _workerFactory;

        public Coordinator(IWorkerFactory workerFactory)
        {
            _workerFactory = workerFactory;
        }

        // Adding 'c' breaks Open/Closed principal for the Coordinator and WorkerFactory; but this has to happen somewhere...
        public string GetWorkerResult(string workerName, int a, List<int> b, string c)
        {
            var worker = _workerFactory.GetWorker(workerName, a, b, c);

            if (worker != null)
                return worker.DoWork();
            else
                return string.Empty;
        }
    }

    public interface IWorker
    {
        string DoWork();
    }

    public class ConcreteWorkerA : IWorker
    {
        private readonly int _a;
        private readonly List<int> _b;

        public ConcreteWorkerA(int a, List<int> b)
        {
            _a = a;
            _b = b;
        }

        public string DoWork()
        {
            // does the required work based on 'a' and 'b'
            return "some A worker result";
        }
    }

    public class ConcreteWorkerB : IWorker
    {
        private readonly int _a;
        private readonly List<int> _b;
        private readonly string _c;

        public ConcreteWorkerB(int a, List<int> b, string c)
        {
            _a = a;
            _b = b;
            _c = c;
        }

        public string DoWork()
        {
            // does some different work based on the value of 'a', 'b' and 'c'
            return "some B worker result";
        }
    }

我建议以下几件事之一。

如果要维护封装，以便呼叫站点不必了解任何有关worker或worker工厂内部工作的信息，则需要更改接口以具有额外的参数。该参数可以具有默认值，以便某些呼叫站点仍可以仅使用2个参数。这将需要重新编译所有使用的库。

我建议您反对的另一个选择，因为它破坏了封装并且通常是糟糕的OOP。这还要求您至少可以修改的所有呼叫站点ConcreteWorkerB。您可以创建一个实现该IWorker接口的类，但也可以使用DoWork带有额外参数的方法。然后在您的调用站点中尝试强制转换IWorkerwith var workerB = myIWorker as ConcreteWorkerB;，然后DoWork在具体类型上使用三个参数。同样，这是一个坏主意，但这是您可以做的。

@Jtech，您考虑过使用该params参数吗？这允许传递可变数量的参数。

https://msdn.microsoft.com/zh-CN/library/w5zay9db(v=vs.71).aspx