Sådan bruges kommando design mønster i C #

Designmønstre er gennemprøvede løsninger, der bruges til at løse almindelige designproblemer og reducere kompleksiteten i kode. Gang of Four designmønstre falder i tre kategorier:

Creational - mønstre relateret til oprettelse af objekter
Strukturelle - mønstre relateret til objektsamling
Adfærdsmønstre - mønstre relateret til objektsamarbejde og adskillelse af ansvar

Kommandodesignmønsteret falder ind under kategorien adfærdsmønstre. Denne artikel udforsker, hvordan vi kan arbejde med kommandodesignmønsteret i C #.

Hvad er kommando design mønster?

Formålet med kommandodesignmønsteret er at afkoble anmoderen om en handling fra det objekt, der udfører handlingen. I kommandodesignmønsteret indkapsles en anmodning som et objekt, der indeholder alle oplysninger om anmodningen. Dette objekt sendes derefter til et invoker-objekt. Invoker-objektet søger derefter efter det passende objekt til at håndtere kommandoen og videresender kommandoen til objektet.

Kommandodesignmønsteret er et godt valg, når du vil implementere tilbagekald, køopgaver, sporingshistorik og fortryd / gentag funktionalitet i din applikation. Kommandomønsteret er et godt valg til implementering af forsøgsmekanismer - når din applikation gerne vil forsøge at oprette forbindelse til en tjeneste på et senere tidspunkt, som ikke er i gang i øjeblikket. Kommandomønsteret bruges også i applikationer til meddelelseskø, dvs. i applikationer, der har brug for at komme sig fra datatab.

Deltagere i kommandodesignmønster

I en klassisk implementering af kommandomønsteret har du fire komponenter: kommandoen, påkalderen, modtageren og klienten. Deltagerne i kommandodesignmønsteret inkluderer følgende:

Kommando - giver en grænseflade til udførelse af en operation
ConcreteCommand - udvider Command-grænsefladen og implementerer Execute-metoden
Klient - starter en ConcreteCommand-klasse
Invoker - informerer kommandoen om at udføre anmodningen
Modtager - indeholder logikken til udførelse af de operationer, der er knyttet til anmodningen

Eksempel på kommando design mønster i C #

I det næste afsnit undersøger vi, hvordan vi kan implementere kommandodesignmønsteret. I vores eksempel implementerer vi en simpel lommeregner ved hjælp af følgende klasser:

Command (Command abstract basisklasse)
SimpleCalculator (modtager klasse)
AddCommand (konkret kommandoklasse)
SubstractCommand (konkret kommandoklasse)
Multiply Command (konkret kommandoklasse)
DivideCommand (konkret kommandoklasse)
Invoker (Invoker-klasse)

Opret kommandabstrakt basisklasse i C #

Overvej følgende abstrakte basisklasse ved navn Command, der indeholder erklæringen om metoden Execute.

offentlig abstrakt klasse Kommando
    {
  beskyttet SimpleCalculator modtager;
  offentlig kommando (SimpleCalculator-modtager)
        {
  this.receiver = modtager;
        }
  offentlig abstrakt int Udfør ();
    }

Følgende enum viser de operationer, der understøttes i vores enkle lommeregner.

offentlig enum CommandOption

{

Tilføj, subtraher, multiplicer, divider

}

Opret modtagerklassen i C #

Følgende er en klasse med navnet SimpleCalculator. Denne klasse fungerer som modtageren og indeholder definitionen af metoderne Add, Subtract, Multiply og Divide.

offentlig klasse SimpleCalculator
    {
  privat int _x, _y;
  offentlig SimpleCalculator (int a, int b)
        {
  _x = a;
  _y = b;
        }
  public int Tilføj ()
        {
  returnere _x + _y;
        }
  public int Træk ()
        {
  returnere _x - _y;
        }
  public int Multiplicer ()
        {
  returnere _x * _y;
        }
  offentlig int Opdel ()
        {
  returnere _x / _y;
        }
    }

Opret de konkrete kommandoklasser i C #

De konkrete kommandoklasser udvider Command-abstrakte basisklassen og implementerer Execute-metoden som vist nedenfor.

 offentlig klasse AddCommand: Kommando
    {
  privat SimpleCalculator _calculator;
  offentlig AddCommand (SimpleCalculator lommeregner): base (lommeregner)
        {
  _calculator = lommeregner;
        }
  offentlig tilsidesættelse int Udfør ()
        {
  returnere _calculator.Add ();
        }
    }
  public class SubtractCommand: Command
    {
  privat SimpleCalculator _calculator;
  public SubtractCommand (SimpleCalculator calculator):
  base (lommeregner)
        {
  _calculator = lommeregner;
        }
  offentlig tilsidesættelse int Udfør ()
        {
  returnere _calculator.Subtract ();
        }
    }
  offentlig klasse MultiplyCommand: Kommando
    {
  privat SimpleCalculator _calculator;
  public MultiplyCommand (SimpleCalculator calculator):
  base (lommeregner)
        {
  _calculator = lommeregner;
        }
  offentlig tilsidesættelse int Udfør ()
        {
  return _calculator.Multiply ();
        }
    }
  offentlig klasse DivideCommand: Kommando
    {
  privat SimpleCalculator _calculator;
  offentlig DivideCommand (SimpleCalculator calculator):
  base (lommeregner)
        {
  _calculator = lommeregner;
        }
  offentlig tilsidesættelse int Udfør ()
        {
  returnere _calculator.Divide ();
        }
    }

Opret Invoker-klassen i C #

Følgende kodestykke illustrerer Invoker-klassen. Den indeholder to metoder, SetCommand og Execute. Mens SetCommand bruges til at tildele kommandobjektet til den private kommandoreference i Invoker-klassen, bruges Execute til at udføre kommandoen.

 offentlig klasse Invoker
    {
  privat kommando _kommando;
  offentlig ugyldighed SetCommand (kommandokommando)
        {
  _command = kommando;
        }
  public int Udfør ()
        {
  returnere _command.Execute ();
        }
    }

Kommando design mønster i aktion i C #

Endelig illustrerer følgende kodestykke, hvordan du kan udføre en simpel beregning ved hjælp af klassen SimpleCalculator.

statisk ugyldigt Main (streng [] args)
        {
  SimpleCalculator calculator = ny SimpleCalculator (15, 3);
  var addCommand = ny AddCommand (lommeregner);
  var substractCommand = ny SubtractCommand (lommeregner);
  var multiplyCommand = ny MultiplyCommand (lommeregner);
  var divideCommand = ny DivideCommand (lommeregner);
  Invoker invoker = ny Invoker ();
  invoker.SetCommand (addCommand);
  Console.WriteLine ("Resultatet er {0}", invoker.Execute ());
  invoker.SetCommand (substractCommand);
  Console.WriteLine ("Resultatet er {0}", invoker.Execute ());
  invoker.SetCommand (multiplyCommand);
  Console.WriteLine ("Resultatet er {0}", invoker.Execute ());
  invoker.SetCommand (divideCommand);
  Console.WriteLine ("Resultatet er {0}", invoker.Execute ());
  Console.ReadLine ();
        }

Kommandodesignmønsteret understøtter strækbarhed og reducerer den kobling, der findes mellem påkalderen og modtageren af en kommando. Da anmodningen er indkapslet i et enkeltstående objekt, kan du parametrere metoder med forskellige anmodninger, gemme anmodninger i en kø og endda yde support til gentagne eller fortrydelige operationer.

—