Pemrograman Berorientasi Objek - cara menghindari duplikasi dalam proses yang sedikit berbeda tergantung pada variabel

Sesuatu yang muncul cukup banyak dalam pekerjaan saya saat ini adalah bahwa ada proses umum yang perlu terjadi, tetapi kemudian bagian aneh dari proses itu perlu terjadi sedikit berbeda tergantung pada nilai variabel tertentu, dan saya tidak cukup yakin apa cara paling elegan untuk menangani ini.

Saya akan menggunakan contoh yang biasanya kita miliki, yang melakukan hal-hal yang sedikit berbeda tergantung pada negara yang kita hadapi.

Jadi saya punya kelas, sebut saja Processor:

public class Processor
{
    public string Process(string country, string text)
    {
        text.Capitalise();

        text.RemovePunctuation();

        text.Replace("é", "e");

        var split = text.Split(",");

        string.Join("|", split);
    }
}

Kecuali bahwa hanya beberapa tindakan yang perlu terjadi untuk negara-negara tertentu. Misalnya, hanya 6 negara yang memerlukan langkah kapitalisasi. Karakter untuk dibagi mungkin berubah tergantung pada negara. Mengganti aksen 'e'mungkin hanya diperlukan tergantung pada negara.

Jelas Anda bisa menyelesaikannya dengan melakukan sesuatu seperti ini:

public string Process(string country, string text)
{
    if (country == "USA" || country == "GBR")
    {
        text.Capitalise();
    }

    if (country == "DEU")
    {
        text.RemovePunctuation();
    }

    if (country != "FRA")
    {
        text.Replace("é", "e");
    }

    var separator = DetermineSeparator(country);
    var split = text.Split(separator);

    string.Join("|", split);
}

Tetapi ketika Anda berurusan dengan semua negara yang mungkin ada di dunia, itu menjadi sangat rumit. Dan terlepas dari itu, ifpernyataan membuat logika lebih sulit untuk dibaca (setidaknya, jika Anda membayangkan metode yang lebih kompleks daripada contoh), dan kompleksitas siklomatik mulai merayap cukup cepat.

Jadi saat ini saya sedang melakukan sesuatu seperti ini:

public class Processor
{
    CountrySpecificHandlerFactory handlerFactory;

    public Processor(CountrySpecificHandlerFactory handlerFactory)
    {
        this.handlerFactory = handlerFactory;
    }

    public string Process(string country, string text)
    {
        var handlers = this.handlerFactory.CreateHandlers(country);
        handlers.Capitalier.Capitalise(text);

        handlers.PunctuationHandler.RemovePunctuation(text);

        handlers.SpecialCharacterHandler.ReplaceSpecialCharacters(text);

        var separator = handlers.SeparatorHandler.DetermineSeparator();
        var split = text.Split(separator);

        string.Join("|", split);
    }
}

Penangan:

public class CountrySpecificHandlerFactory
{
    private static IDictionary<string, ICapitaliser> capitaliserDictionary
                                    = new Dictionary<string, ICapitaliser>
    {
        { "USA", new Capitaliser() },
        { "GBR", new Capitaliser() },
        { "FRA", new ThingThatDoesNotCapitaliseButImplementsICapitaliser() },
        { "DEU", new ThingThatDoesNotCapitaliseButImplementsICapitaliser() },
    };

    // Imagine the other dictionaries like this...

    public CreateHandlers(string country)
    {
        return new CountrySpecificHandlers
        {
            Capitaliser = capitaliserDictionary[country],
            PunctuationHanlder = punctuationDictionary[country],
            // etc...
        };
    }
}

public class CountrySpecificHandlers
{
    public ICapitaliser Capitaliser { get; private set; }
    public IPunctuationHanlder PunctuationHanlder { get; private set; }
    public ISpecialCharacterHandler SpecialCharacterHandler { get; private set; }
    public ISeparatorHandler SeparatorHandler { get; private set; }
}

Yang sama saya tidak yakin saya suka. Logikanya masih agak dikaburkan oleh semua pembuatan pabrik dan Anda tidak bisa begitu saja melihat metode asli dan melihat apa yang terjadi ketika proses "GBR" dijalankan, misalnya. Anda juga akhirnya menciptakan banyak kelas (dalam contoh yang lebih kompleks dari ini) dalam gaya GbrPunctuationHandler,, UsaPunctuationHandlerdll ... yang berarti Anda harus melihat beberapa kelas yang berbeda untuk mencari tahu semua tindakan yang mungkin bisa terjadi selama tanda baca penanganan. Jelas saya tidak ingin satu kelas raksasa dengan satu miliar ifpernyataan, tetapi sama-sama 20 kelas dengan logika yang sedikit berbeda juga terasa kikuk.

Pada dasarnya saya pikir saya telah mendapatkan semacam simpul OOP dan tidak tahu cara yang baik untuk menguraikannya. Saya bertanya-tanya apakah ada pola di luar sana yang akan membantu dengan jenis proses ini?

Saya akan menyarankan merangkum semua opsi dalam satu kelas:

public class ProcessOptions
{
  public bool Capitalise { get; set; }
  public bool RemovePunctuation { get; set; }
  public bool Replace { get; set; }
  public char ReplaceChar { get; set; }
  public char ReplacementChar { get; set; }
  public char JoinChar { get; set; }
  public char SplitChar { get; set; }
}

dan meneruskannya ke Processmetode:

public string Process(ProcessOptions options, string text)
{
  if(options.Capitalise)
    text.Capitalise();

  if(options.RemovePunctuation)
    text.RemovePunctuation();

  if(options.Replace)
    text.Replace(options.ReplaceChar, options.ReplacementChar);

  var split = text.Split(options.SplitChar);

  string.Join(options.JoinChar, split);
}

Ketika .NET framework ditetapkan untuk menangani masalah-masalah semacam ini, itu tidak memodelkan semuanya sebagai string. Jadi Anda memiliki, misalnya, CultureInfokelas :

Memberikan informasi tentang budaya tertentu (disebut lokal untuk pengembangan kode yang tidak dikelola). Informasi mencakup nama-nama untuk budaya, sistem penulisan, kalender yang digunakan, urutan pengurutan, dan pemformatan untuk tanggal dan angka.

Sekarang, kelas ini mungkin tidak mengandung fitur spesifik yang Anda butuhkan, tetapi Anda jelas dapat membuat sesuatu yang analog. Dan kemudian Anda mengubah Processmetode Anda :

public string Process(CountryInfo country, string text)

CountryInfoKelas Anda kemudian dapat memiliki abool RequiresCapitalization properti, dll, yang membantu Processmetode Anda mengarahkan pemrosesan dengan tepat.

Mungkin Anda bisa memiliki satu Processorper negara?

public class FrProcessor : Processor {
    protected override string Separator => ".";

    protected override string ProcessSpecific(string text) {
        return text.Replace("é", "e");
    }
}

public class UsaProcessor : Processor {
    protected override string Separator => ",";

    protected override string ProcessSpecific(string text) {
        return text.Capitalise().RemovePunctuation();
    }
}

Dan satu kelas dasar untuk menangani bagian umum dari pemrosesan:

public abstract class Processor {
    protected abstract string Separator { get; }

    protected virtual string ProcessSpecific(string text) { }

    private string ProcessCommon(string text) {
        var split = text.Split(Separator);
        return string.Join("|", split);
    }

    public string Process(string text) {
        var s = ProcessSpecific(text);
        return ProcessCommon(s);
    }
}

Selain itu, Anda harus mengolah kembali tipe pengembalian Anda karena tidak akan dikompilasi saat Anda menulisnya - terkadang stringmetode tidak mengembalikan apa pun.

Anda dapat membuat antarmuka umum dengan Processmetode ...

public interface IProcessor
{
    string Process(string text);
}

Maka Anda menerapkannya untuk setiap negara ...

public class Processors
{
    public class GBR : IProcessor
    {
        public string Process(string text)
        {
            return $"{text} (processed with GBR rules)";
        }
    }

    public class FRA : IProcessor
    {
        public string Process(string text)
        {
            return $"{text} (processed with FRA rules)";
        }
    }
}

Anda kemudian dapat membuat metode umum untuk membuat instance dan mengeksekusi masing-masing kelas terkait negara ...

// also place these in the Processors class above
public static IProcessor CreateProcessor(string country)
{
    var typeName = $"{typeof(Processors).FullName}+{country}";
    var processor = (IProcessor)Assembly.GetAssembly(typeof(Processors)).CreateInstance(typeName);
    return processor;
}

public static string Process(string country, string text)
{
    var processor = CreateProcessor(country);
    return processor?.Process(text);
}

Maka Anda hanya perlu membuat dan menggunakan prosesor seperti ...

// create a processor object for multiple use, if needed...
var processorGbr = Processors.CreateProcessor("GBR");
Console.WriteLine(processorGbr.Process("This is some text."));

// create and use a processor for one-time use
Console.WriteLine(Processors.Process("FRA", "This is some more text."));

Berikut ini contoh biola dotnet yang berfungsi ...

Anda menempatkan semua pemrosesan khusus negara di setiap kelas negara. Buat kelas umum (dalam kelas Pemrosesan) untuk semua metode individu yang sebenarnya, sehingga setiap prosesor negara menjadi daftar panggilan umum lainnya, daripada menyalin kode di setiap kelas negara.

Catatan: Anda harus menambahkan ...

using System.Assembly;

agar metode statis untuk membuat turunan dari kelas negara.

Beberapa versi yang lalu, C # swtich diberi dukungan penuh untuk pencocokan pola . Sehingga kasus "banyak negara cocok" mudah dilakukan. Meskipun masih tidak memiliki kemampuan jatuh, satu input dapat mencocokkan banyak kasus dengan pencocokan pola. Mungkin bisa membuat itu jika-spam sedikit lebih jelas.

Npw, sebuah sakelar biasanya dapat diganti dengan Koleksi. Anda harus menggunakan Delegasi dan Kamus. Proses dapat diganti dengan.

public delegate string ProcessDelegate(string text);

Maka Anda bisa membuat Kamus:

var Processors = new Dictionary<string, ProcessDelegate>(){
  { "USA", EnglishProcessor },
  { "GBR", EnglishProcessor },
  { "DEU", GermanProcessor }
}

Saya menggunakan functionNames untuk menyerahkan Delegasi. Tapi Anda bisa menggunakan sintaks Lambda untuk menyediakan seluruh kode di sana. Dengan begitu, Anda bisa menyembunyikan seluruh Koleksi itu seperti halnya koleksi besar lainnya. Dan kode menjadi pencarian sederhana:

ProcessDelegate currentProcessor = Processors[country];
string processedString = currentProcessor(country);

Itu adalah dua pilihan. Anda mungkin ingin mempertimbangkan untuk menggunakan Enumerasi alih-alih string untuk pencocokan, tetapi itu adalah detail kecil.

Saya mungkin (tergantung pada detail kasus penggunaan Anda) pergi dengan Country menjadi objek "nyata", bukan string. Kata kuncinya adalah "polimorfisme".

Jadi pada dasarnya akan terlihat seperti ini:

public interface Country {
   string Process(string text);
}

Kemudian Anda dapat membuat negara khusus untuk yang Anda butuhkan. Catatan: Anda tidak harus membuat Countryobjek untuk semua negara, Anda bisa LatinlikeCountry, atau bahkan GenericCountry. Di sana Anda dapat mengumpulkan apa yang harus dilakukan, bahkan menggunakan kembali yang lain, seperti:

public class France {
   public string Process(string text) {
      return new GenericCountry().process(text)
         .replace('a', 'b');
   }
}

Atau serupa. Countrymungkin sebenarnya Language, saya tidak yakin tentang kasus penggunaan, tapi saya mengerti maksudnya.

Juga, metode tentu saja tidak harus Process()itu harus menjadi hal yang benar-benar perlu Anda lakukan. Suka Words()atau apalah.

Anda ingin mendelegasikan (mengangguk ke rantai tanggung jawab) sesuatu yang tahu tentang budaya sendiri. Jadi gunakan atau buat tipe Negara atau CultureInfo, seperti yang disebutkan di atas dalam jawaban lain.

Tetapi secara umum dan mendasar masalah Anda adalah Anda mengambil konstruksi prosedural seperti 'prosesor' dan menerapkannya pada OO. OO adalah tentang mewakili konsep dunia nyata dari bisnis atau domain masalah dalam perangkat lunak. Prosesor tidak menerjemahkan apa pun di dunia nyata selain dari perangkat lunak itu sendiri. Setiap kali Anda memiliki kelas seperti Prosesor atau Manajer atau Gubernur, bel alarm akan berbunyi.

Saya bertanya-tanya apakah ada pola di luar sana yang akan membantu dengan jenis proses ini

Rantai tanggung jawab adalah jenis hal yang mungkin Anda cari tetapi dalam OOP agak rumit ...

Bagaimana dengan pendekatan yang lebih fungsional dengan C #?

using System;


namespace Kata {

  class Kata {


    static void Main() {

      var text = "     testing this thing for DEU          ";
      Console.WriteLine(Process.For("DEU")(text));

      text = "     testing this thing for USA          ";
      Console.WriteLine(Process.For("USA")(text));

      Console.ReadKey();
    }

    public static class Process {

      public static Func<string, string> For(string country) {

        Func<string, string> baseFnc = (string text) => text;

        var aggregatedFnc = ApplyToUpper(baseFnc, country);
        aggregatedFnc = ApplyTrim(aggregatedFnc, country);

        return aggregatedFnc;

      }

      private static Func<string, string> ApplyToUpper(Func<string, string> currentFnc, string country) {

        string toUpper(string text) => currentFnc(text).ToUpper();

        Func<string, string> fnc = null;

        switch (country) {
          case "USA":
          case "GBR":
          case "DEU":
            fnc = toUpper;
            break;
          default:
            fnc = currentFnc;
            break;
        }
        return fnc;
      }

      private static Func<string, string> ApplyTrim(Func<string, string> currentFnc, string country) {

        string trim(string text) => currentFnc(text).Trim();

        Func<string, string> fnc = null;

        switch (country) {
          case "DEU":
            fnc = trim;
            break;
          default:
            fnc = currentFnc;
            break;
        }
        return fnc;
      }
    }
  }
}

CATATAN: Tentu saja tidak harus statis. Jika kelas Proses memerlukan status Anda dapat menggunakan kelas instances atau fungsi yang diterapkan sebagian;).

Anda dapat membangun Proses untuk setiap negara pada permulaan, menyimpan masing-masing dalam koleksi yang diindeks dan mengambilnya saat dibutuhkan dengan biaya O (1).

Saya minta maaf karena saya telah lama menciptakan istilah "objek" untuk topik ini karena itu membuat banyak orang untuk fokus pada ide yang lebih rendah. Ide besarnya adalah olahpesan .

~ Alan Kay, On Messaging

Saya hanya akan menerapkan rutinitas Capitalise, RemovePunctuationdll. Sebagai subproses yang dapat mengirim pesan dengan a textdan countryparameter, dan akan mengembalikan teks yang diproses.

Gunakan kamus untuk mengelompokkan negara yang sesuai dengan atribut tertentu (jika Anda lebih suka daftar, itu akan bekerja dengan baik hanya dengan sedikit biaya kinerja). Misalnya: CapitalisationApplicableCountriesdan PunctuationRemovalApplicableCountries.

/// Runs like a pipe: passing the text through several stages of subprocesses
public string Process(string country, string text)
{
    text = Capitalise(country, text);
    text = RemovePunctuation(country, text);
    // And so on and so forth...

    return text;
}

private string Capitalise(string country, string text)
{
    if ( ! CapitalisationApplicableCountries.ContainsKey(country) )
    {
        /* skip */
        return text;
    }

    /* do the capitalisation */
    return capitalisedText;
}

private string RemovePunctuation(string country, string text)
{
    if ( ! PunctuationRemovalApplicableCountries.ContainsKey(country) )
    {
        /* skip */
        return text;
    }

    /* do the punctuation removal */
    return punctuationFreeText;
}

private string Replace(string country, string text)
{
    // Implement it following the pattern demonstrated earlier.
}

Saya merasa bahwa informasi tentang negara harus disimpan dalam data, bukan dalam kode. Jadi, alih-alih kelas CountryInfo atau CapitalisationApplicableCountries dictionary, Anda bisa memiliki database dengan catatan untuk setiap negara dan bidang untuk setiap langkah pemrosesan, dan kemudian pemrosesan bisa melalui bidang untuk negara tertentu dan memproses sesuai. Pemeliharaan kemudian terutama dalam database, dengan kode baru hanya diperlukan ketika langkah-langkah baru diperlukan, dan data dapat dibaca manusia dalam database. Ini mengasumsikan langkah-langkahnya independen dan tidak saling mengganggu; jika tidak demikian maka segala sesuatunya rumit.