C # Pola Desain untuk pekerja dengan parameter input berbeda

Saya tidak yakin pola desain mana yang dapat membantu saya mengatasi masalah ini.

Saya memiliki kelas, 'Koordinator', yang menentukan kelas Pekerja mana yang harus digunakan - tanpa harus tahu tentang semua jenis Pekerja yang ada - hanya memanggil WorkerFactory dan bertindak berdasarkan antarmuka IWorker yang umum.

Kemudian menetapkan Pekerja yang sesuai untuk bekerja dan mengembalikan hasil metode 'DoWork'.

Ini baik-baik saja ... sampai sekarang; kami memiliki persyaratan baru untuk kelas Pekerja baru, "WorkerB" yang membutuhkan sejumlah informasi tambahan yaitu parameter input tambahan, agar dapat melakukan tugasnya.

Seperti kita membutuhkan metode DoWork yang kelebihan beban dengan parameter input ekstra ... tapi kemudian semua Pekerja yang ada harus menerapkan metode itu - yang tampaknya salah karena Pekerja itu benar-benar tidak memerlukan metode itu.

Bagaimana saya bisa menolak ini agar Koordinator tidak mengetahui Pekerja mana yang sedang digunakan dan masih memungkinkan setiap Pekerja untuk mendapatkan informasi yang diperlukan untuk melakukan tugasnya tetapi tidak ada Pekerja yang melakukan hal-hal yang tidak perlu?

Sudah banyak Pekerja yang ada.

Saya tidak ingin harus mengubah salah satu Pekerja beton yang ada untuk mengakomodasi persyaratan kelas WorkerB baru.

Saya pikir mungkin pola Penghias akan baik di sini, tetapi saya belum melihat Penghias menghiasi objek dengan metode yang sama tetapi parameter yang berbeda sebelum ...

Situasi dalam kode:

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

Anda perlu menggeneralisasi argumen agar sesuai dengan parameter tunggal dengan antarmuka dasar dan sejumlah variabel bidang atau properti. Semacam seperti ini:

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

Perhatikan cek nol ... karena sistem Anda fleksibel dan terikat, ini juga bukan tipe aman, jadi Anda perlu memeriksa gips untuk memastikan argumen yang disahkan valid.

Jika Anda benar-benar tidak ingin membuat objek konkret untuk setiap kemungkinan kombinasi argumen, Anda bisa menggunakan tuple sebagai gantinya (tidak akan menjadi pilihan pertama saya.)

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

Saya telah merekayasa ulang solusi berdasarkan komentar @ Dunk:

... Anda sudah tahu semua parameter yang diperlukan sebelum instance IWorker dibuat. Dengan demikian, Anda harus meneruskan argumen tersebut ke konstruktor dan bukan metode DoWork. TKI, manfaatkan kelas pabrik Anda. Menyembunyikan detail pembuatan instance cukup banyak menjadi alasan utama keberadaan kelas pabrik.

Jadi saya telah menggeser semua argumen yang mungkin diperlukan untuk membuat IWorker menjadi metode IWorerFactory.GetWorker dan kemudian masing-masing pekerja sudah memiliki apa yang dibutuhkannya dan Koordinator dapat memanggil pekerja saja. 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";
        }
    }

Saya akan menyarankan satu dari beberapa hal.

Jika Anda ingin mempertahankan enkapsulasi, sehingga panggilan tidak perlu tahu apa-apa tentang cara kerja pekerja atau pabrik pekerja, maka Anda harus mengubah antarmuka untuk memiliki parameter tambahan. Parameter dapat memiliki nilai default, sehingga beberapa callsite masih bisa menggunakan 2 parameter. Ini akan mengharuskan perpustakaan yang mengkonsumsi dikompilasi ulang.

Pilihan lain yang saya sarankan, karena itu merusak enkapsulasi dan umumnya OOP buruk. Ini juga mengharuskan Anda setidaknya dapat memodifikasi semua panggilan untuk ConcreteWorkerB. Anda bisa membuat kelas yang mengimplementasikan IWorkerantarmuka, tetapi juga memiliki DoWorkmetode dengan parameter tambahan. Kemudian dalam panggilan Anda, coba untuk membuang IWorkerdengan var workerB = myIWorker as ConcreteWorkerB;dan kemudian gunakan tiga parameter DoWorkpada jenis beton. Sekali lagi, ini adalah ide yang buruk, tetapi itu adalah sesuatu yang bisa Anda lakukan.

@Jtech, sudahkah Anda mempertimbangkan penggunaan paramsargumen? Ini memungkinkan sejumlah variabel parameter dilewatkan.

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