Programování

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.

Udělejte více s C #:

  • Jak pracovat s AutoMapperem v C #
  • Kdy použít abstraktní třídu vs. rozhraní v C #
  • Jak pracovat s vlákny v C #
  • Jak používat Dapper ORM v C #
  • Jak implementovat vzor návrhu úložiště v C #
  • Jak implementovat jednoduchý záznamník v C #
  • Jak pracovat s delegáty v C #
  • Jak pracovat s delegáty Action, Func a Predicate v C #
  • Jak pracovat s log4net v C #
  • Jak pracovat s odrazem v C #