Jak používat vzor návrhu příkazu v C #

Návrhové vzory jsou osvědčená řešení používaná k řešení běžných návrhových problémů a ke snížení složitosti kódu. Návrhový vzor Gang of Four lze rozdělit do tří kategorií:

Creational - vzory související s tvorbou objektů
Strukturální - vzory vztahující se k montáži objektů
Behaviorální - vzorce vztahující se ke spolupráci na objektech a oddělení odpovědnosti

Návrhový vzor příkazu spadá do kategorie vzorů chování. Tento článek zkoumá, jak můžeme pracovat se vzorem návrhu příkazu v C #.

Jaký je návrhový vzor příkazu?

Záměrem vzoru návrhu příkazu je oddělit žadatele od akce od objektu, který akci provádí. V návrhovém vzoru příkazu je požadavek zapouzdřen jako objekt, který obsahuje všechny informace o požadavku. Tento objekt je poté předán objektu vyvolávajícího. Objekt volajícího pak hledá vhodný objekt pro zpracování příkazu a předá příkaz objektu.

Návrhový vzor příkazu je dobrou volbou, pokud chcete ve své aplikaci implementovat zpětná volání, úkoly ve frontě, historii sledování a funkce zpět / znovu. Vzor příkazu je dobrou volbou pro implementaci mechanismů opakování - když by se vaše aplikace chtěla znovu pokusit o připojení ke službě v pozdějším okamžiku, který v tuto chvíli není funkční. Příkazový vzor se také používá v aplikacích zařazování do fronty zpráv, tj. V aplikacích, které je třeba obnovit ze ztráty dat.

Účastníci návrhu vzorů příkazů

V klasické implementaci vzoru příkazů máte čtyři komponenty: příkaz, vyvolávač, příjemce a klient. Mezi účastníky vzoru návrhu příkazu patří:

Příkaz - poskytuje rozhraní pro provedení operace
ConcreteCommand - rozšiřuje příkazové rozhraní a implementuje metodu Execute
Klient - vytvoří instanci třídy ConcreteCommand
Vyvolávač - informuje příkaz k provedení požadavku
Přijímač - obsahuje logiku pro provádění operací spojených s požadavkem

Příklad návrhového vzoru příkazu v C #

V další části prozkoumáme, jak můžeme implementovat vzor návrhu příkazu. V našem příkladu implementujeme jednoduchou kalkulačku pomocí následujících tříd:

Příkaz (Základní třída příkazů)
SimpleCalculator (třída přijímače)
AddCommand (konkrétní třída příkazů)
SubstractCommand (konkrétní třída příkazů)
Násobit příkaz (konkrétní třída příkazů)
DivideCommand (konkrétní třída příkazů)
Invoker (třída Invoker)

Vytvořte základní třídu příkazů v C #

Zvažte následující abstraktní základní třídu s názvem Command, která obsahuje deklaraci metody Execute.

Příkaz veřejné třídy abstrakt
    {
  chráněný přijímač SimpleCalculator;
  public Command (přijímač SimpleCalculator)
        {
  this.receiver = přijímač;
        }
  public abstract int Execute ();
    }

Následující výčet ukazuje operace, které budou podporovány v naší jednoduché kalkulačce.

veřejné výčet CommandOption

{

Přidat, podložit, znásobit, rozdělit

}

Vytvořte třídu přijímače v C #

Následuje třída s názvem SimpleCalculator. Tato třída funguje jako přijímač a obsahuje definici metod Add, Subtract, Multiply a Divide.

veřejná třída SimpleCalculator
    {
  private int _x, _y;
  veřejný SimpleCalculator (int a, int b)
        {
  _x = a;
  _y = b;
        }
  public int Přidat ()
        {
  návrat _x + _y;
        }
  public int Odečíst ()
        {
  návrat _x - _y;
        }
  public int Násobení ()
        {
  návrat _x * _y;
        }
  public int Divide ()
        {
  návrat _x / _y;
        }
    }

Vytvořte konkrétní třídy příkazů v C #

Konkrétní třídy příkazů rozšiřují základní třídu Command Abstract a implementují metodu Execute, jak je znázorněno níže.

 veřejná třída AddCommand: Příkaz
    {
  soukromý SimpleCalculator _calculator;
  public AddCommand (kalkulačka SimpleCalculator): základna (kalkulačka)
        {
  _calculator = kalkulačka;
        }
  veřejné přepsání int Execute ()
        {
  návrat _calculator.Add ();
        }
    }
  veřejná třída SubtractCommand: Příkaz
    {
  soukromý SimpleCalculator _calculator;
  veřejný SubtractCommand (kalkulačka SimpleCalculator):
  základna (kalkulačka)
        {
  _calculator = kalkulačka;
        }
  veřejné přepsání int Execute ()
        {
  návrat _calculator.Subtract ();
        }
    }
  veřejná třída MultiplyCommand: Příkaz
    {
  soukromý SimpleCalculator _calculator;
  veřejný MultiplyCommand (kalkulačka SimpleCalculator):
  základna (kalkulačka)
        {
  _calculator = kalkulačka;
        }
  veřejné přepsání int Execute ()
        {
  návrat _calculator.Multiply ();
        }
    }
  veřejná třída DivideCommand: Příkaz
    {
  soukromý SimpleCalculator _calculator;
  public DivideCommand (kalkulačka SimpleCalculator):
  základna (kalkulačka)
        {
  _calculator = kalkulačka;
        }
  veřejné přepsání int Execute ()
        {
  návrat _calculator.Divide ();
        }
    }

Vytvořte třídu Invoker v C #

Následující fragment kódu ilustruje třídu Invoker. Obsahuje dvě metody, SetCommand a Execute. Zatímco SetCommand se používá k přiřazení objektu příkazu k soukromé reference příkazu ve třídě Invoker, Execute se používá k provedení příkazu.

 veřejná třída Invoker
    {
  soukromý příkaz _command;
  public void SetCommand (příkazový příkaz)
        {
  _command = příkaz;
        }
  public int Execute ()
        {
  návrat _command.Execute ();
        }
    }

Návrhový vzor příkazu v akci v C #

Nakonec následující fragment kódu ukazuje, jak můžete provést jednoduchý výpočet pomocí třídy SimpleCalculator.

static void Main (řetězec [] 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ýsledek je {0}", invoker.Execute ());
  invoker.SetCommand (substractCommand);
  Console.WriteLine ("Výsledek je {0}", invoker.Execute ());
  invoker.SetCommand (multiplyCommand);
  Console.WriteLine ("Výsledek je {0}", invoker.Execute ());
  invoker.SetCommand (divideCommand);
  Console.WriteLine ("Výsledek je {0}", invoker.Execute ());
  Console.ReadLine ();
        }

Návrhový vzor příkazu poskytuje podporu pro rozšiřitelnost a snižuje propojení, které existuje mezi vyvolávačem a přijímačem příkazu. Vzhledem k tomu, že požadavek je zapouzdřen do samostatného objektu, můžete parametrizovat metody s různými požadavky, ukládat požadavky do fronty a dokonce poskytovat podporu pro operace s možností opětovného použití nebo zrušení možnosti.

—