C # -Designmuster für Mitarbeiter mit unterschiedlichen Eingabeparametern

Ich bin mir nicht sicher, welches Entwurfsmuster mir bei der Lösung dieses Problems helfen könnte.

Ich habe eine Klasse, 'Coordinator', die festlegt, welche Worker-Klasse verwendet werden soll - ohne über die verschiedenen Arten von Workern Bescheid wissen zu müssen -, ruft einfach eine WorkerFactory auf und reagiert auf die gemeinsame IWorker-Schnittstelle.

Anschließend setzt es den entsprechenden Worker auf Arbeit und gibt das Ergebnis seiner DoWork-Methode zurück.

Das war in Ordnung ... bis jetzt; Wir haben eine neue Anforderung für eine neue Worker-Klasse, "WorkerB", die eine zusätzliche Menge an Informationen benötigt, dh einen zusätzlichen Eingabeparameter, damit sie ihre Arbeit erledigen kann.

Es ist, als ob wir eine überladene DoWork-Methode mit dem zusätzlichen Eingabeparameter benötigen ... aber dann müssten alle vorhandenen Worker diese Methode implementieren - was falsch erscheint, da diese Worker diese Methode wirklich nicht benötigen.

Wie kann ich dies umgestalten, damit der Koordinator nicht weiß, welcher Mitarbeiter verwendet wird, und jedem Mitarbeiter weiterhin die Informationen zur Verfügung stellt, die er für seine Arbeit benötigt, ohne dass ein Mitarbeiter Dinge tut, die er nicht benötigt?

Es gibt bereits viele existierende Arbeiter.

Ich möchte keinen der vorhandenen konkreten Worker ändern müssen, um den Anforderungen der neuen WorkerB-Klasse gerecht zu werden.

Ich dachte, vielleicht wäre ein Dekorationsmuster hier gut, aber ich habe noch nie gesehen, dass Dekorateure ein Objekt mit derselben Methode, aber unterschiedlichen Parametern dekorieren ...

Situation im Code:

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";
    }    
}

Sie müssen die Argumente so verallgemeinern, dass sie in einen einzelnen Parameter mit einer Basisschnittstelle und einer variablen Anzahl von Feldern oder Eigenschaften passen. So ähnlich:

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";
    }
} 

Beachten Sie die Nullprüfungen ... da Ihr System flexibel und spät gebunden ist, ist es auch nicht typsicher. Sie müssen daher Ihre Besetzung überprüfen, um sicherzustellen, dass die übergebenen Argumente gültig sind.

Wenn Sie wirklich nicht für jede mögliche Kombination von Argumenten konkrete Objekte erstellen möchten, können Sie stattdessen ein Tupel verwenden (wäre nicht meine erste Wahl.)

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);

Ich habe die Lösung basierend auf dem Kommentar von @ Dunk überarbeitet:

... Sie kennen bereits alle Parameter, die vor dem Erstellen der IWorker-Instanz benötigt werden. Daher sollten Sie diese Argumente an den Konstruktor und nicht an die DoWork-Methode übergeben haben. IOW, nutzen Sie Ihre Fabrikklasse. Das Ausblenden der Details beim Erstellen der Instanz ist so ziemlich der Hauptgrund für die Existenz der Factory-Klasse.

Daher habe ich alle möglichen Argumente, die zum Erstellen eines IWorker erforderlich sind, in die IWorerFactory.GetWorker-Methode verschoben. Dann hat jeder Worker bereits das, was er benötigt, und der Koordinator kann einfach worker.DoWork () aufrufen.

    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";
        }
    }

Ich würde eines von mehreren Dingen vorschlagen.

Wenn Sie die Kapselung beibehalten möchten, damit die Callsites nichts über das Innenleben der Arbeiter oder der Arbeiterfabrik wissen müssen, müssen Sie die Schnittstelle ändern, um den zusätzlichen Parameter zu erhalten. Der Parameter kann einen Standardwert haben, sodass einige Call-Sites immer noch nur 2 Parameter verwenden können. Dies erfordert, dass alle verbrauchenden Bibliotheken neu kompiliert werden.

Die andere Option würde ich dagegen empfehlen, da sie die Kapselung unterbricht und im Allgemeinen nur eine schlechte OOP ist. Dies erfordert auch, dass Sie mindestens alle Call-Sites für ändern können ConcreteWorkerB. Sie können eine Klasse erstellen, die die IWorkerSchnittstelle implementiert , aber auch eine DoWorkMethode mit einem zusätzlichen Parameter hat. Versuchen Sie dann auf Ihren Callsites, das IWorkerwith zu konvertieren, var workerB = myIWorker as ConcreteWorkerB;und verwenden Sie dann die drei Parameter DoWorkfür den konkreten Typ. Auch dies ist eine schlechte Idee, aber es ist etwas, was Sie tun könnten .

@Jtech, hast du über die Verwendung des paramsArguments nachgedacht ? Dadurch kann eine variable Anzahl von Parametern übergeben werden.

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