Ako používať vzor návrhu príkazov v C #

Dizajnové vzory sú osvedčené riešenia používané na riešenie bežných problémov s návrhom a na zníženie zložitosti kódu. Dizajn Gang of Four možno rozdeliť do troch kategórií:

Creational - vzory týkajúce sa vytvárania objektov
Štrukturálne - vzory súvisiace so zostavovaním objektov
Behaviorálne - vzorce týkajúce sa spolupráce na objektoch a oddelenia zodpovednosti

Návrhový vzor príkazu spadá do kategórie vzorov správania. Tento článok skúma, ako môžeme pracovať so vzorom návrhu príkazov v C #.

Aký je vzor návrhu príkazu?

Účelom vzoru návrhu príkazu je oddeliť žiadateľa od akcie od objektu, ktorý akciu vykonáva. V návrhovom vzore príkazu je požiadavka zapuzdrená ako objekt, ktorý obsahuje všetky informácie o požiadavke. Tento objekt sa potom odovzdá objektu vyvolávača. Objekt vyvolávača potom vyhľadá vhodný objekt na spracovanie príkazu a odovzdá príkaz objektu.

Vzor návrhu príkazov je dobrou voľbou, ak chcete vo svojej aplikácii implementovať spätné volania, úlohy zaradenia do frontu, históriu sledovania a funkcie späť / znova. Vzor príkazov je dobrou voľbou na implementáciu mechanizmov opakovania - keď by sa vaša aplikácia chcela znova pokúsiť pripojiť k službe v neskoršom okamihu, ktorý v súčasnosti nie je funkčný. Vzor príkazu sa používa aj v aplikáciách na zaradenie do frontu správ, t. J. V aplikáciách, ktoré sa musia zotaviť zo straty dát.

Účastníci príkazového vzoru

V klasickej implementácii príkazového vzoru máte štyri komponenty: príkaz, vyvolávač, príjemca a klient. Medzi účastníkov návrhového vzoru príkazu patria:

Príkaz - poskytuje rozhranie na vykonanie operácie
ConcreteCommand - rozširuje príkazové rozhranie a implementuje metódu Execute
Klient - vytvorí inštanciu triedy ConcreteCommand
Vyvolávač - informuje príkaz na vykonanie požiadavky
Prijímač - obsahuje logiku pre vykonávanie operácií spojených s požiadavkou

Príklad vzorového príkazového príkazu v C #

V nasledujúcej časti sa pozrieme na to, ako môžeme implementovať vzor návrhu príkazov. V našom príklade implementujeme jednoduchú kalkulačku pomocou nasledujúcich tried:

Príkaz (Základná trieda abstraktu príkazu)
SimpleCalculator (trieda prijímača)
AddCommand (konkrétna trieda príkazov)
SubstractCommand (konkrétna trieda príkazov)
Násobenie príkazu (konkrétna trieda príkazov)
DivideCommand (konkrétna trieda príkazov)
Invoker (trieda Invoker)

Vytvorte základnú triedu abstraktu príkazu v C #

Zvážte nasledujúcu abstraktnú základnú triedu s názvom Command, ktorá obsahuje deklaráciu metódy Execute.

príkaz pre verejnú abstraktnú triedu
    {
  chránený prijímač SimpleCalculator;
  verejné velenie (prijímač SimpleCalculator)
        {
  this.receiver = prijímač;
        }
  public abstract int Execute ();
    }

Nasledujúci výčet zobrazuje operácie, ktoré bude podporovať naša jednoduchá kalkulačka.

verejný výčet CommandOption

{

Sčítanie, podtext, násobenie, delenie

}

Vytvorte triedu prijímača v C #

Toto je trieda s názvom SimpleCalculator. Táto trieda funguje ako prijímač a obsahuje definíciu metód sčítania, odčítania, násobenia a delenia.

verejná trieda SimpleCalculator
    {
  private int _x, _y;
  verejný SimpleCalculator (int a, int b)
        {
  _x = a;
  _y = b;
        }
  public int Pridať ()
        {
  návrat _x + _y;
        }
  public int Odčítať ()
        {
  návrat _x - _y;
        }
  public int Násobiť ()
        {
  návrat _x * _y;
        }
  public int Rozdeliť ()
        {
  návrat _x / _y;
        }
    }

Vytvorte konkrétne triedy príkazov v C #

Konkrétne triedy príkazov rozširujú základnú triedu abstraktných príkazov a implementujú metódu Execute, ako je uvedené nižšie.

 verejná trieda AddCommand: Príkaz
    {
  súkromný SimpleCalculator _calculator;
  public AddCommand (kalkulačka SimpleCalculator): základňa (kalkulačka)
        {
  _kalkulačka = kalkulačka;
        }
  verejné prepísanie int Execute ()
        {
  return _calculator.Add ();
        }
    }
  verejná trieda SubtractCommand: Príkaz
    {
  súkromný SimpleCalculator _calculator;
  verejný SubtractCommand (kalkulačka SimpleCalculator):
  základ (kalkulačka)
        {
  _kalkulačka = kalkulačka;
        }
  verejné prepísanie int Execute ()
        {
  návrat _calculator.Subtract ();
        }
    }
  verejná trieda MultiplyCommand: Príkaz
    {
  súkromný SimpleCalculator _calculator;
  verejný MultiplyCommand (kalkulačka SimpleCalculator):
  základ (kalkulačka)
        {
  _kalkulačka = kalkulačka;
        }
  verejné prepísanie int Execute ()
        {
  návrat _calculator.Multiply ();
        }
    }
  verejná trieda DivideCommand: Príkaz
    {
  súkromný SimpleCalculator _calculator;
  public DivideCommand (kalkulačka SimpleCalculator):
  základ (kalkulačka)
        {
  _kalkulačka = kalkulačka;
        }
  verejné prepísanie int Execute ()
        {
  návrat _calculator.Divide ();
        }
    }

Vytvorte triedu Invoker v C #

Nasledujúci úryvok kódu ilustruje triedu Invoker. Obsahuje dve metódy, SetCommand a Execute. Zatiaľ čo SetCommand sa používa na priradenie objektu príkazu k súkromnej referencii príkazu v triede Invoker, na vykonanie príkazu sa používa príkaz Execute.

 verejná trieda Invoker
    {
  súkromný príkaz _príkaz;
  public void SetCommand (príkazový príkaz)
        {
  _command = príkaz;
        }
  public int Execute ()
        {
  return _command.Execute ();
        }
    }

Návrhový vzor príkazu v akcii v C #

Na záver nasledujúci úryvok kódu ilustruje, ako môžete vykonať jednoduchý výpočet pomocou triedy SimpleCalculator.

static void Main (reťazec [] args)
        {
  Kalkulačka SimpleCalculator = nový SimpleCalculator (15, 3);
  var addCommand = nový AddCommand (kalkulačka);
  var substractCommand = nový SubtractCommand (kalkulačka);
  var multiplyCommand = nový MultiplyCommand (kalkulačka);
  var divideCommand = nový DivideCommand (kalkulačka);
  Vyvolávač Vyvolávač = nový Vyvolávač ();
  invoker.SetCommand (addCommand);
  Console.WriteLine ("Výsledok je {0}", invoker.Execute ());
  invoker.SetCommand (substractCommand);
  Console.WriteLine ("Výsledok je {0}", invoker.Execute ());
  invoker.SetCommand (multiplyCommand);
  Console.WriteLine ("Výsledok je {0}", invoker.Execute ());
  invoker.SetCommand (divideCommand);
  Console.WriteLine ("Výsledok je {0}", invoker.Execute ());
  Console.ReadLine ();
        }

Návrhový vzor príkazu poskytuje podporu pre rozšíriteľnosť a znižuje väzbu, ktorá existuje medzi vyvolávačom a prijímateľom príkazu. Pretože je požiadavka zapuzdrená do samostatného objektu, môžete parametrizovať metódy s rôznymi požiadavkami, ukladať požiadavky do frontu a dokonca poskytovať podporu pre operácie s možnosťou opakovaného alebo zrušenia možnosti.

—