Cara menggunakan corak reka bentuk perintah di C #

Corak reka bentuk adalah penyelesaian yang terbukti digunakan untuk menyelesaikan masalah reka bentuk biasa dan mengurangkan kerumitan dalam kod. Corak reka bentuk Gang of Four tergolong dalam tiga kategori:

  • Penciptaan - corak yang berkaitan dengan penciptaan objek
  • Struktural - corak yang berkaitan dengan pemasangan objek
  • Tingkah laku - corak yang berkaitan dengan kerjasama objek dan pemisahan tanggungjawab

Corak reka bentuk arahan tergolong dalam kategori corak tingkah laku. Artikel ini menerangkan bagaimana kita dapat bekerja dengan corak reka bentuk perintah di C #.

Apakah corak reka bentuk arahan?

Maksud corak reka bentuk perintah adalah untuk memutuskan pemohon tindakan dari objek yang melaksanakan tindakan. Dalam pola desain perintah, permintaan dibungkus sebagai objek yang berisi semua informasi tentang permintaan tersebut. Objek ini kemudian dihantar ke objek invoker. Objek invoker kemudian mencari objek yang sesuai untuk menangani perintah dan menyampaikan perintah ke objek tersebut.

Corak reka bentuk perintah adalah pilihan yang baik ketika anda ingin melaksanakan panggilan balik, tugas giliran, sejarah pelacakan, dan fungsi batalkan / buat semula dalam aplikasi anda. Corak arahan adalah pilihan yang baik untuk menerapkan mekanisme percubaan - apabila aplikasi anda ingin mencuba semula penyambungan ke perkhidmatan pada waktu yang akan datang dan tidak berjalan pada masa ini. Pola Perintah juga digunakan dalam aplikasi antrian pesan, yaitu, dalam aplikasi yang perlu pulih dari kehilangan data.

Peserta corak reka bentuk arahan

Dalam pelaksanaan klasik corak Perintah, anda mempunyai empat komponen: perintah, penyerang, penerima, dan pelanggan. Peserta dalam corak reka bentuk arahan merangkumi yang berikut:

  • Perintah - menyediakan antara muka untuk melaksanakan operasi
  • ConcreteCommand - memperluas antara muka Command dan melaksanakan kaedah Execute
  • Pelanggan - mewujudkan kelas ConcreteCommand
  • Invoker - memberitahu arahan untuk melaksanakan permintaan tersebut
  • Penerima - mengandungi logik untuk melaksanakan operasi yang berkaitan dengan permintaan

Contoh corak reka bentuk arahan dalam C #

Di bahagian seterusnya kita akan meneroka bagaimana kita dapat melaksanakan corak reka bentuk perintah. Dalam contoh kami, kami akan melaksanakan kalkulator mudah menggunakan kelas berikut:

  • Perintah (kelas asas abstrak arahan)
  • SimpleCalculator (Kelas penerima)
  • AddCommand (kelas arahan konkrit)
  • SubstrakCommand (kelas arahan konkrit)
  • Multiply Command (kelas arahan konkrit)
  • DivideCommand (kelas arahan konkrit)
  • Invoker (kelas Invoker)

Buat kelas asas abstrak Perintah di C #

Pertimbangkan kelas dasar abstrak berikut bernama Command yang mengandungi deklarasi kaedah Execute.

Komando kelas abstrak awam

    {

        penerima SimpleCalculator yang dilindungi;

        Perintah awam (penerima SimpleCalculator)

        {

            ini.receiver = penerima;

        }

        awam abstrak int Laksanakan ();

    }

Enum berikut menunjukkan operasi yang akan disokong dalam kalkulator mudah kami.

CommandOption enum awam

    {

        Tambah, Abstrak, Darab, Bahagikan

    }

Buat kelas Penerima di C #

Berikut adalah kelas bernama SimpleCalculator. Kelas ini bertindak sebagai Penerima dan mengandungi definisi kaedah Tambah, Kurangkan, Darab, dan Bahagikan.

SimpleCalculator kelas awam

    {

        int peribadi xx, _y;

        SimpleCalculator awam (int a, int b)

        {

            _x = a;

            _y = b;

        }

        int awam Tambah ()

        {

            pulangkan _x + _y;

        }

        tolak int awam ()

        {

            pulangkan _x - _y;

        }

        awam int Multiply ()

        {

            pulangkan _x * _y;

        }

        awam int Divide ()

        {

            pulangkan _x / _y;

        }

    }

Buat kelas arahan konkrit di C #

Kelas arahan konkrit meluaskan kelas asas abstrak Perintah dan melaksanakan kaedah Jalankan seperti yang ditunjukkan di bawah.

 kelas awam AddCommand: Perintah

    {

        SimpleCalculator _calculator peribadi;

        umum AddCommand (kalkulator SimpleCalculator): asas (kalkulator)

        {

            _kalkulator = kalkulator;

        }

        penolakan awam int Execute ()

        {

            pulangkan _calculator.Add ();

        }

    }

    SubtractCommand kelas awam: Perintah

    {

        SimpleCalculator _calculator peribadi;

        public SubtractCommand (kalkulator SimpleCalculator):

        asas (kalkulator)

        {

            _kalkulator = kalkulator;

        }

        penolakan awam int Execute ()

        {

            pulangkan _calculator.Subtract ();

        }

    }

    kelas awam MultiplyCommand: Perintah

    {

        SimpleCalculator _calculator peribadi;

        awam MultiplyCommand (kalkulator SimpleCalculator):

        asas (kalkulator)

        {

            _kalkulator = kalkulator;

        }

        penolakan awam int Execute ()

        {

            kembali _calculator.Multiply ();

        }

    }

    kelas awam DivideCommand: Perintah

    {

        SimpleCalculator _calculator peribadi;

        public DivideCommand (kalkulator SimpleCalculator):

        asas (kalkulator)

        {

            _kalkulator = kalkulator;

        }

        penolakan awam int Execute ()

        {

            kembali _calculator.Divide ();

        }

    }

Buat kelas Invoker di C #

Coretan kod berikut menggambarkan kelas Invoker. Ia mengandungi dua kaedah, SetCommand dan Execute. Sementara SetCommand digunakan untuk menetapkan objek perintah ke rujukan Perintah pribadi di kelas Invoker, Execute digunakan untuk melaksanakan perintah.

    Invoker kelas awam

    {

        Perintah peribadi _command;

        kekosongan awam SetCommand (arahan Perintah)

        {

            _command = arahan;

        }

        awam int Melaksanakan ()

        {

            kembali _command.Execute ();

        }

    }

Corak reka bentuk arahan dalam tindakan di C #

Akhirnya, coretan kod berikut menggambarkan bagaimana anda dapat melakukan pengiraan mudah menggunakan kelas SimpleCalculator.

kekosongan statik Utama (string [] args)

        {

            Kalkulator SimpleCalculator = SimpleCalculator baru (15, 3);

            var addCommand = AddCommand baru (kalkulator);

            var substractCommand = SubtractCommand baru (kalkulator);

            var multiplyCommand = MultiplyCommand baru (kalkulator);

            var divideCommand = DivideCommand baru (kalkulator);

            Invoker invoker = Invoker baru ();

            invoker.SetCommand (addCommand);

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

            invoker.SetCommand (substractCommand);

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

            invoker.SetCommand (multiplyCommand);

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

            invoker.SetCommand (divideCommand);

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

            Konsol.ReadLine ();

        }

Corak reka bentuk arahan memberikan sokongan untuk kepanjangan dan mengurangkan gandingan yang ada antara penyerang dan penerima arahan. Oleh kerana permintaan itu dikemas ke dalam objek yang berdiri sendiri, anda dapat memaret parameter kaedah dengan permintaan yang berbeda, menyimpan permintaan dalam barisan, dan bahkan memberikan sokongan untuk operasi yang dapat dilakukan ulang atau yang tidak dapat dilakukan.

-

Lakukan lebih banyak perkara dengan C #:

  • Cara bekerja dengan AutoMapper di C #
  • Bilakah menggunakan kelas abstrak vs antara muka dalam C #
  • Cara bekerja dengan benang di C #
  • Cara menggunakan Dapper ORM di C #
  • Cara melaksanakan corak reka bentuk repositori di C #
  • Cara melaksanakan pembalak sederhana di C #
  • Cara bekerja dengan perwakilan di C #
  • Cara bekerjasama dengan delegasi Action, Func, dan Predicate di C #
  • Cara bekerja dengan log4net di C #
  • Cara bekerja dengan refleksi di C #