Cara menggunakan pola desain perintah di C #

Pola desain adalah solusi yang terbukti digunakan untuk memecahkan masalah desain umum dan mengurangi kerumitan dalam kode. Pola desain Gang of Four terbagi dalam tiga kategori:

  • Penciptaan - pola yang terkait dengan pembuatan objek
  • Struktural - pola yang terkait dengan perakitan objek
  • Perilaku - pola yang terkait dengan kolaborasi objek dan pemisahan tanggung jawab

Pola desain perintah termasuk dalam kategori pola perilaku. Artikel ini membahas bagaimana kita dapat bekerja dengan pola desain perintah di C #.

Apa pola desain perintahnya?

Maksud dari pola desain perintah adalah untuk memisahkan pemohon tindakan dari objek yang menjalankan tindakan tersebut. Dalam pola desain perintah, permintaan dienkapsulasi sebagai objek yang berisi semua informasi tentang permintaan tersebut. Objek ini kemudian diteruskan ke objek invoker. Objek invoker kemudian mencari objek yang sesuai untuk menangani perintah dan meneruskan perintah ke objek tersebut.

Pola desain perintah adalah pilihan yang baik saat Anda ingin menerapkan panggilan balik, tugas antrian, riwayat pelacakan, dan fungsi urungkan / ulangi dalam aplikasi Anda. Pola perintah adalah pilihan yang baik untuk mengimplementasikan mekanisme percobaan ulang - ketika aplikasi Anda ingin mencoba kembali menghubungkan ke layanan di lain waktu yang tidak aktif dan berjalan saat ini. Pola Perintah juga digunakan dalam aplikasi antrian pesan, yaitu dalam aplikasi yang perlu memulihkan dari kehilangan data.

Peserta pola desain perintah

Dalam implementasi klasik dari pola Perintah, Anda memiliki empat komponen: perintah, pemanggil, penerima, dan klien. Para peserta dalam pola desain perintah meliputi:

  • Command - menyediakan antarmuka untuk menjalankan operasi
  • ConcreteCommand - memperluas antarmuka Command dan mengimplementasikan metode Execute
  • Klien - membuat instance kelas ConcreteCommand
  • Invoker - menginformasikan perintah untuk menjalankan permintaan
  • Penerima - berisi logika untuk menjalankan operasi yang terkait dengan permintaan

Contoh pola desain perintah di C #

Di bagian selanjutnya kita akan menjelajahi bagaimana kita dapat mengimplementasikan pola desain perintah. Dalam contoh kami, kami akan menerapkan kalkulator sederhana menggunakan kelas-kelas berikut:

  • Command (Perintah kelas dasar abstrak)
  • SimpleCalculator (kelas Penerima)
  • AddCommand (kelas perintah beton)
  • SubstractCommand (kelas perintah beton)
  • Multiply Command (kelas perintah konkret)
  • DivideCommand (kelas perintah beton)
  • Invoker (kelas Invoker)

Buat kelas dasar Command abstract di C #

Pertimbangkan kelas dasar abstrak berikut bernama Command yang berisi deklarasi metode Execute.

Perintah kelas abstrak publik

    {

        penerima SimpleCalculator yang dilindungi;

        Perintah publik (penerima SimpleCalculator)

        {

            this.receiver = receiver;

        }

        public abstract int Execute ();

    }

Enum berikut menunjukkan operasi yang akan didukung dalam kalkulator sederhana kami.

public enum CommandOption

    {

        Tambahkan, Kurangi, Kalikan, Bagi

    }

Buat kelas Penerima di C #

Berikut ini adalah kelas bernama SimpleCalculator. Kelas ini bertindak sebagai Penerima dan berisi definisi metode Tambah, Kurangi, Kalikan, dan Bagi.

SimpleCalculator kelas publik

    {

        pribadi int _x, _y;

        SimpleCalculator publik (int a, int b)

        {

            _x = a;

            _y = b;

        }

        public int Add ()

        {

            kembali _x + _y;

        }

        public int Subtract ()

        {

            kembali _x - _y;

        }

        public int Multiply ()

        {

            kembali _x * _y;

        }

        public int Divide ()

        {

            kembali _x / _y;

        }

    }

Buat kelas perintah konkret di C #

Kelas perintah konkret memperluas kelas dasar abstrak Perintah dan mengimplementasikan metode Execute seperti yang ditunjukkan di bawah ini.

 kelas publik AddCommand: Command

    {

        SimpleCalculator _calculator pribadi;

        publik AddCommand (kalkulator SimpleCalculator): basis (kalkulator)

        {

            _calculator = kalkulator;

        }

        public override int Execute ()

        {

            return _calculator.Add ();

        }

    }

    kelas publik SubtractCommand: Command

    {

        SimpleCalculator _calculator pribadi;

        public SubtractCommand (kalkulator SimpleCalculator):

        dasar (kalkulator)

        {

            _calculator = kalkulator;

        }

        public override int Execute ()

        {

            return _calculator.Subtract ();

        }

    }

    kelas publik MultiplyCommand: Command

    {

        SimpleCalculator _calculator pribadi;

        public MultiplyCommand (kalkulator SimpleCalculator):

        dasar (kalkulator)

        {

            _calculator = kalkulator;

        }

        public override int Execute ()

        {

            return _calculator.Multiply ();

        }

    }

    kelas publik DivideCommand: Command

    {

        SimpleCalculator _calculator pribadi;

        public DivideCommand (kalkulator SimpleCalculator):

        dasar (kalkulator)

        {

            _calculator = kalkulator;

        }

        public override int Execute ()

        {

            return _calculator.Divide ();

        }

    }

Buat kelas Invoker di C #

Potongan kode berikut menggambarkan kelas Invoker. Ini berisi dua metode, SetCommand dan Execute. Sementara SetCommand digunakan untuk menetapkan objek perintah ke referensi Perintah pribadi di kelas Invoker, Execute digunakan untuk menjalankan perintah.

    kelas publik Invoker

    {

        Perintah pribadi _command;

        public void SetCommand (perintah Command)

        {

            _command = perintah;

        }

        public int Execute ()

        {

            return _command.Execute ();

        }

    }

Pola desain perintah beraksi di C #

Terakhir, cuplikan kode berikut mengilustrasikan bagaimana Anda dapat melakukan penghitungan sederhana menggunakan kelas SimpleCalculator.

static void Main (string [] args)

        {

            SimpleCalculator calculator = SimpleCalculator baru (15, 3);

            var addCommand = new AddCommand (kalkulator);

            var substractCommand = baru SubtractCommand (kalkulator);

            var multiplyCommand = new MultiplyCommand (kalkulator);

            var divideCommand = new DivideCommand (kalkulator);

            Invoker invoker = new Invoker ();

            invoker.SetCommand (addCommand);

            Console.WriteLine ("Hasil adalah {0}", invoker.Execute ());

            invoker.SetCommand (substractCommand);

            Console.WriteLine ("Hasil adalah {0}", invoker.Execute ());

            invoker.SetCommand (multiplyCommand);

            Console.WriteLine ("Hasil adalah {0}", invoker.Execute ());

            invoker.SetCommand (divideCommand);

            Console.WriteLine ("Hasil adalah {0}", invoker.Execute ());

            Console.ReadLine ();

        }

Pola desain perintah memberikan dukungan untuk ekstensibilitas dan mengurangi kopling yang ada antara pemanggil dan penerima perintah. Karena permintaan dienkapsulasi menjadi objek yang berdiri sendiri, Anda dapat membuat parameter metode dengan permintaan berbeda, menyimpan permintaan dalam antrean, dan bahkan memberikan dukungan untuk operasi yang dapat diulang atau dibatalkan.

-

Lakukan lebih banyak dengan C #:

  • Bagaimana bekerja dengan AutoMapper di C #
  • Kapan menggunakan kelas abstrak vs. antarmuka di C #
  • Cara bekerja dengan utas di C #
  • Cara menggunakan Dapper ORM di C #
  • Bagaimana menerapkan pola desain repositori di C #
  • Bagaimana menerapkan logger sederhana di C #
  • Bagaimana bekerja dengan delegasi di C #
  • Cara bekerja dengan delegasi Action, Func, dan Predicate di C #
  • Bagaimana bekerja dengan log4net di C #
  • Bagaimana bekerja dengan refleksi di C #