Kuinka käyttää komentosuunnittelukuviota C #: ssä

Suunnittelumallit ovat todistettuja ratkaisuja, joita käytetään yleisten suunnitteluongelmien ratkaisemiseen ja koodin monimutkaisuuden vähentämiseen. Neljän ryhmän jengi jakautuu kolmeen luokkaan:

Luova - esineiden luomiseen liittyvät mallit
Rakenne - esineiden kokoonpanoon liittyvät kuviot
Käyttäytyminen - esineyhteistyöhön ja vastuiden jakamiseen liittyvät mallit

Komennon suunnittelumalli kuuluu käyttäytymismalliluokkaan. Tässä artikkelissa tutkitaan, miten voimme työskennellä komentojen suunnittelumallin kanssa C #: ssä.

Mikä on komennon suunnittelumalli?

Komennon suunnittelumallin tarkoituksena on erottaa toiminnan pyytäjä toiminnosta suorittavasta objektista. Komennon suunnittelumallissa pyyntö kapseloidaan objektiksi, joka sisältää kaikki tiedot pyynnöstä. Tämä objekti välitetään sitten kutsutulle objektille. Kutsujan kohde etsii sitten sopivan objektin komennon käsittelemiseksi ja välittää komennon objektille.

Komennon suunnittelumalli on hyvä valinta, kun haluat ottaa käyttöön soittopyynnöt, jonotustehtävät, seurantahistorian ja kumota / tee uudelleen toiminnot sovelluksessasi. Komentomalli on hyvä valinta yrittää mekanismeja uudelleen - kun sovelluksesi haluaa yrittää muodostaa yhteyden palveluun myöhemmin myöhemmin, joka ei ole käynnissä tällä hetkellä. Komentokuviota käytetään myös sanomajärjestyssovelluksissa, so. Sovelluksissa, joiden on palaututtava tietojen menetyksestä.

Komennon suunnittelukuvion osallistujat

Klassisessa Command-mallin toteutuksessa sinulla on neljä komponenttia: komento, invoker, vastaanotin ja asiakas. Komennon suunnittelumallin osallistujat ovat seuraavat:

Komento - tarjoaa käyttöliittymän operaation suorittamiseen
ConcreteCommand - laajentaa komentorajapintaa ja toteuttaa Execute-menetelmän
Asiakas - välittää ConcreteCommand-luokan
Kutsuja - ilmoittaa komennolle pyynnön suorittamisen
Vastaanotin - sisältää logiikan pyyntöön liittyvien toimintojen suorittamiseen

Esimerkki komentosuunnittelukuviosta C #: ssä

Seuraavassa osassa tutkitaan, miten voimme toteuttaa komentojen suunnittelumallin. Esimerkissämme toteutamme yksinkertaisen laskimen seuraavilla luokilla:

Komento (komennon abstrakti perusluokka)
SimpleCalculator (Vastaanottoluokka)
AddCommand (konkreettinen komentoluokka)
SubtractCommand (konkreettinen komentoluokka)
Kerro komento (konkreettinen komentoluokka)
DivideCommand (konkreettinen komentoluokka)
Invoker (Invoker-luokka)

Luo komennon abstrakti perusluokka C #

Harkitse seuraavaa abstraktia perusluokkaa nimeltä Command, joka sisältää Execute-menetelmän ilmoituksen.

julkisen abstraktin luokan komento
    {
  suojattu SimpleCalculator-vastaanotin;
  julkinen komento (SimpleCalculator-vastaanotin)
        {
  this.receiver = vastaanotin;
        }
  public abstract int Suorita ();
    }

Seuraava luettelo näyttää toiminnot, joita yksinkertainen laskin tukee.

public enum CommandOption
    {
  Lisää, vähennä, kerro, jaa
    }

Luo vastaanottajaluokka C #

Seuraava on luokan nimeltään SimpleCalculator. Tämä luokka toimii vastaanottimena ja sisältää määritelmän Lisää, vähennä, kerro ja jaa -menetelmille.

julkisen luokan SimpleCalculator
    {
  yksityinen int _x, _y;
  julkinen SimpleCalculator (int a, int b)
        {
  _x = a;
  _y = b;
        }
  public int Lisää ()
        {
  paluu _x + _y;
        }
  public int Vähennä ()
        {
  paluu _x - _y;
        }
  julkinen moninkertaistaa ()
        {
  paluu _x * _y;
        }
  public int Divide ()
        {
  paluu _x / _y;
        }
    }

Luo konkreettiset komentoluokat C #: ssä

Konkreettiset komentoluokat laajentavat Command-abstraktin perusluokan ja toteuttavat Execute-menetelmän alla olevan kuvan mukaisesti.

 public class AddCommand: Komento
    {
  yksityinen SimpleCalculator _calculator;
  public AddCommand (SimpleCalculator calculator): pohja (laskin)
        {
  _laskuri = laskin;
        }
  julkinen ohitus int Suorita ()
        {
  return _calculator.Add ();
        }
    }
  public class SubtractCommand: Komento
    {
  yksityinen SimpleCalculator _calculator;
  public SubtractCommand (SimpleCalculator-laskin):
  pohja (laskin)
        {
  _laskuri = laskin;
        }
  julkinen ohitus int Suorita ()
        {
  return _calculator.Subtract ();
        }
    }
  public class MultiplyCommand: Komento
    {
  yksityinen SimpleCalculator _calculator;
  public MultiplyCommand (SimpleCalculator calculator):
  pohja (laskin)
        {
  _laskuri = laskin;
        }
  julkinen ohitus int Suorita ()
        {
  return _calculator.Multiply ();
        }
    }
  julkinen luokka DivideCommand: Komento
    {
  yksityinen SimpleCalculator _calculator;
  julkinen DivideCommand (SimpleCalculator-laskin):
  pohja (laskin)
        {
  _laskuri = laskin;
        }
  julkinen ohitus int Suorita ()
        {
  return _calculator.Divide ();
        }
    }

Luo Invoker-luokka C #

Seuraava koodinpätkä kuvaa Invoker-luokkaa. Se sisältää kaksi tapaa, SetCommand ja Execute. Vaikka SetCommandia käytetään komento-objektin määrittämiseen Invoker-luokan yksityiselle komentoviitteelle, Execute-komentoa käytetään komennon suorittamiseen.

 julkinen luokka Invoker
    {
  yksityinen komento _komento;
  public void SetCommand (komentokomento)
        {
  _command = komento;
        }
  julkinen int Suorita ()
        {
  return _command.Execute ();
        }
    }

Komennon suunnittelumalli toiminnassa C #

Lopuksi seuraava koodinpätkä kuvaa, kuinka voit suorittaa yksinkertaisen laskutoimituksen käyttämällä SimpleCalculator-luokkaa.

staattinen void Main (merkkijono [] args)
        {
  SimpleCalculator calculator = uusi SimpleCalculator (15, 3);
  var addCommand = uusi AddCommand (laskin);
  var subtractCommand = uusi SubtractCommand (laskin);
  var multiplyCommand = uusi MultiplyCommand (laskin);
  var divideCommand = uusi DivideCommand (laskin);
  Invoker invoker = uusi kutsuttaja ();
  invoker.SetCommand (addCommand);
  Console.WriteLine ("Tulos on {0}", invoker.Execute ());
  invoker.SetCommand (subtractCommand);
  Console.WriteLine ("Tulos on {0}", invoker.Execute ());
  invoker.SetCommand (multiplyCommand);
  Console.WriteLine ("Tulos on {0}", invoker.Execute ());
  invoker.SetCommand (divideCommand);
  Console.WriteLine ("Tulos on {0}", invoker.Execute ());
  Console.ReadLine ();
        }

Komennon suunnittelumalli tukee laajennettavuutta ja vähentää kytkentää, joka vallitsee komennon kutsun ja vastaanottimen välillä. Koska pyyntö on kapseloitu erilliseksi objektiksi, voit parametroida menetelmiä erilaisilla pyynnöillä, tallentaa pyynnöt jonoon ja jopa tarjota tukea uudelleen- tai kumottaville toiminnoille.

—