Programmering

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.

Gør mere med C #:

  • Sådan arbejder du med AutoMapper i C #
  • Hvornår skal man bruge en abstrakt klasse vs. interface i C #
  • Sådan arbejder du med tråde i C #
  • Sådan bruges Dapper ORM i C #
  • Sådan implementeres depotdesignmønsteret i C #
  • Sådan implementeres en simpel logger i C #
  • Sådan arbejder du med delegerede i C #
  • Sådan arbejder du med Action-, Func- og Predicate-delegerede i C #
  • Sådan arbejder du med log4net i C #
  • Sådan arbejder du med refleksion i C #