Πώς να χρησιμοποιήσετε το μοτίβο σχεδιασμού εντολών στο C #

Τα πρότυπα σχεδιασμού είναι αποδεδειγμένες λύσεις που χρησιμοποιούνται για την επίλυση κοινών προβλημάτων σχεδιασμού και τη μείωση των πολυπλοκότητας στον κώδικα. Τα σχέδια του Gang of Four εμπίπτουν σε τρεις κατηγορίες:

Δημιουργία - μοτίβα που σχετίζονται με τη δημιουργία αντικειμένων
Δομικά - μοτίβα που σχετίζονται με τη συναρμολόγηση αντικειμένων
Συμπεριφορά - πρότυπα που σχετίζονται με τη συνεργασία αντικειμένων και το διαχωρισμό των ευθυνών

Το μοτίβο σχεδίασης εντολών εμπίπτει στην κατηγορία προτύπων συμπεριφοράς. Αυτό το άρθρο διερευνά πώς μπορούμε να εργαστούμε με το μοτίβο σχεδίασης εντολών στο C #.

Ποιο είναι το σχέδιο σχεδιασμού εντολών;

Ο σκοπός του μοτίβου σχεδίασης εντολών είναι να αποσυνδέσει τον αιτούντα μιας ενέργειας από το αντικείμενο που εκτελεί την ενέργεια. Στο μοτίβο σχεδίασης εντολών, ένα αίτημα ενσωματώνεται ως αντικείμενο που περιέχει όλες τις πληροφορίες σχετικά με το αίτημα. Αυτό το αντικείμενο μεταφέρεται στη συνέχεια σε ένα αντικείμενο εισβολέα. Στη συνέχεια, το αντικείμενο του εισβολέα αναζητά το κατάλληλο αντικείμενο για να χειριστεί την εντολή και μεταβιβάζει την εντολή στο αντικείμενο.

Το μοτίβο σχεδιασμού εντολών είναι μια καλή επιλογή όταν θέλετε να εφαρμόσετε επιστροφές κλήσεων, εργασίες ουράς, ιστορικό παρακολούθησης και λειτουργίες αναίρεσης / επανάληψης στην εφαρμογή σας. Το μοτίβο εντολών είναι μια καλή επιλογή για την εφαρμογή μηχανισμών επανάληψης - όταν η εφαρμογή σας θα ήθελε να προσπαθήσει ξανά να συνδεθεί σε μια υπηρεσία σε μεταγενέστερο χρονικό σημείο που δεν είναι σε λειτουργία αυτή τη στιγμή. Το μοτίβο εντολών χρησιμοποιείται επίσης σε εφαρμογές ουράς μηνυμάτων, δηλαδή σε εφαρμογές που πρέπει να ανακτήσουν από την απώλεια δεδομένων.

Συμμετέχοντες μοτίβο σχεδίασης

Σε μια κλασική εφαρμογή του μοτίβου εντολών έχετε τέσσερα στοιχεία: την εντολή, τον εισβολέα, τον παραλήπτη και τον πελάτη. Οι συμμετέχοντες στο σχέδιο σχεδιασμού εντολών περιλαμβάνουν τα ακόλουθα:

Command - παρέχει μια διεπαφή για την εκτέλεση μιας λειτουργίας
ConcreteCommand - επεκτείνει τη διεπαφή εντολών και εφαρμόζει τη μέθοδο εκτέλεσης
Πελάτης - δημιουργεί μια κλάση ConcreteCommand
Invoker - ενημερώνει την εντολή για την εκτέλεση του αιτήματος
Δέκτης - περιέχει τη λογική για την εκτέλεση των λειτουργιών που σχετίζονται με το αίτημα

Παράδειγμα σχεδίασης εντολών σε C #

Στην επόμενη ενότητα θα διερευνήσουμε πώς μπορούμε να εφαρμόσουμε το σχέδιο σχεδίασης εντολών. Στο παράδειγμά μας, θα εφαρμόσουμε μια απλή αριθμομηχανή χρησιμοποιώντας τις ακόλουθες κατηγορίες:

Εντολή (Εντολή αφηρημένης βασικής κλάσης)
SimpleCalculator (Κατηγορία δέκτη)
AddCommand (συγκεκριμένη κλάση εντολών)
SubstractCommand (συγκεκριμένη κλάση εντολών)
Multiply Command (συγκεκριμένη κλάση εντολών)
DivideCommand (συγκεκριμένη κλάση εντολών)
Invoker (τάξη Invoker)

Δημιουργήστε την κλάση βασικής αφηρημένης εντολής στο C #

Εξετάστε την ακόλουθη αφηρημένη βασική κλάση με το όνομα Command που περιέχει τη δήλωση της μεθόδου Execute

δημόσια αφηρημένη τάξη Command
    {
  προστατευμένος δέκτης SimpleCalculator.
  δημόσια εντολή (δέκτης SimpleCalculator)
        {
  this.receiver = δέκτης;
        }
  δημόσια περίληψη int Execute ();
    }

Το παρακάτω enum δείχνει τις λειτουργίες που θα υποστηρίζονται στον απλό υπολογιστή μας.

public enum CommandOption
    {
  Προσθέστε, αφαιρέστε, πολλαπλασιάστε, διαιρέστε
    }

Δημιουργήστε την τάξη δέκτη σε C #

Το παρακάτω είναι μια τάξη που ονομάζεται SimpleCalculator. Αυτή η τάξη λειτουργεί ως Παραλήπτης και περιέχει τον ορισμό των μεθόδων Προσθήκη, Αφαίρεση, Πολλαπλασιασμός και Διαίρεση.

δημόσια τάξη SimpleCalculator
    {
  ιδιωτικό int _x, _y;
  δημόσιο SimpleCalculator (int a, int b)
        {
  _x = α;
  _y = β;
        }
  δημόσια int Προσθήκη ()
        {
  επιστροφή _x + _y;
        }
  δημόσια int αφαίρεση ()
        {
  επιστροφή _x - _y;
        }
  δημόσια int Multiply ()
        {
  επιστροφή _x * _y;
        }
  δημόσια int Divide ()
        {
  επιστροφή _x / _y;
        }
    }

Δημιουργήστε τις συγκεκριμένες τάξεις εντολών στο C #

Οι συγκεκριμένες κλάσεις εντολών επεκτείνουν την κλάση βασικής αφηρημένης εντολής και εφαρμόζουν τη μέθοδο εκτέλεσης όπως φαίνεται παρακάτω.

 δημόσια τάξη AddCommand: Command
    {
  ιδιωτικό SimpleCalculator _calculator;
  δημόσια AddCommand (SimpleCalculator calculator): βάση (αριθμομηχανή)
        {
  _calculator = αριθμομηχανή;
        }
  δημόσια παράκαμψη int Execute ()
        {
  επιστροφή _calculator.Add ();
        }
    }
  δημόσια τάξη SubtractCommand: Εντολή
    {
  ιδιωτικό SimpleCalculator _calculator;
  public SubtractCommand (SimpleCalculator αριθμομηχανή):
  βάση (αριθμομηχανή)
        {
  _calculator = αριθμομηχανή;
        }
  δημόσια παράκαμψη int Execute ()
        {
  επιστροφή _calculator.Subtract ();
        }
    }
  δημόσια τάξη MultiplyCommand: Command
    {
  ιδιωτικό SimpleCalculator _calculator;
  public MultiplyCommand (αριθμομηχανή SimpleCalculator):
  βάση (αριθμομηχανή)
        {
  _calculator = αριθμομηχανή;
        }
  δημόσια παράκαμψη int Execute ()
        {
  επιστροφή _calculator.Multiply ();
        }
    }
  δημόσια τάξη DivideCommand: Εντολή
    {
  ιδιωτικό SimpleCalculator _calculator;
  δημόσιο DivideCommand (αριθμομηχανή SimpleCalculator):
  βάση (αριθμομηχανή)
        {
  _calculator = αριθμομηχανή;
        }
  δημόσια παράκαμψη int Execute ()
        {
  επιστροφή _calculator.Divide ();
        }
    }

Δημιουργήστε την τάξη Invoker στο C #

Το παρακάτω απόσπασμα κώδικα απεικονίζει την τάξη Invoker. Περιέχει δύο μεθόδους, το SetCommand και το Execute. Ενώ το SetCommand χρησιμοποιείται για την εκχώρηση του αντικειμένου εντολής στην ιδιωτική αναφορά εντολών στην κλάση Invoker, το Execute χρησιμοποιείται για την εκτέλεση της εντολής.

 δημόσια τάξη Invoker
    {
  ιδιωτική εντολή _command;
  public void SetCommand (εντολή εντολής)
        {
  _command = εντολή;
        }
  δημόσια int Execute ()
        {
  επιστροφή _command.Execute ();
        }
    }

Το μοτίβο σχεδιασμού εντολών σε δράση στο C #

Τέλος, το παρακάτω απόσπασμα κώδικα δείχνει πώς μπορείτε να εκτελέσετε έναν απλό υπολογισμό χρησιμοποιώντας την κλάση SimpleCalculator.

static void Main (συμβολοσειρά [] args)
        {
  Αριθμομηχανή SimpleCalculator = νέο SimpleCalculator (15, 3);
  var addCommand = νέο AddCommand (αριθμομηχανή);
  var substractCommand = νέο SubtractCommand (αριθμομηχανή);
  var multiplyCommand = νέο MultiplyCommand (αριθμομηχανή);
  var divideCommand = νέο DivideCommand (αριθμομηχανή);
  Invoker invoker = νέο Invoker ();
  invoker.SetCommand (addCommand);
  Console.WriteLine ("Το αποτέλεσμα είναι {0}", invoker.Execute ());
  invoker.SetCommand (substractCommand);
  Console.WriteLine ("Το αποτέλεσμα είναι {0}", invoker.Execute ());
  invoker.SetCommand (multiplyCommand);
  Console.WriteLine ("Το αποτέλεσμα είναι {0}", invoker.Execute ());
  invoker.SetCommand (divideCommand);
  Console.WriteLine ("Το αποτέλεσμα είναι {0}", invoker.Execute ());
  Console.ReadLine ();
        }

Το σχέδιο σχεδιασμού εντολών παρέχει υποστήριξη για επεκτασιμότητα και μειώνει τη σύνδεση που υπάρχει μεταξύ του εισβολέα και του δέκτη μιας εντολής. Δεδομένου ότι το αίτημα είναι ενσωματωμένο σε αυτόνομο αντικείμενο, μπορείτε να παραμετροποιήσετε μεθόδους με διαφορετικά αιτήματα, να αποθηκεύσετε αιτήματα σε μια ουρά και ακόμη και να παρέχετε υποστήριξη για λειτουργίες επαναφοράς ή αναίρεσης.

—