Comment utiliser le modèle de conception de commande en C #

Les modèles de conception sont des solutions éprouvées utilisées pour résoudre les problèmes de conception courants et réduire la complexité du code. Les modèles de conception du Gang of Four se divisent en trois catégories:

  • Créatif - modèles liés à la création d'objets
  • Structurel - motifs liés à l'assemblage d'objets
  • Comportementale - modèles liés à la collaboration d'objets et à la séparation des responsabilités

Le modèle de conception de commande relève de la catégorie de modèle comportemental. Cet article explore comment nous pouvons travailler avec le modèle de conception de commande en C #.

Quel est le modèle de conception de commande?

L'intention du modèle de conception de commande est de découpler le demandeur d'une action de l'objet qui exécute l'action. Dans le modèle de conception de commande, une demande est encapsulée en tant qu'objet contenant toutes les informations sur la demande. Cet objet est ensuite passé à un objet invocateur. L'objet appelant recherche ensuite l'objet approprié pour gérer la commande et la transmet à l'objet.

Le modèle de conception de commande est un bon choix lorsque vous souhaitez implémenter des rappels, des tâches de mise en file d'attente, l'historique de suivi et des fonctionnalités d'annulation / rétablissement dans votre application. Le modèle de commande est un bon choix pour implémenter des mécanismes de nouvelle tentative - lorsque votre application souhaite tenter à nouveau de se connecter à un service à un moment ultérieur qui n'est pas opérationnel pour le moment. Le modèle Command est également utilisé dans les applications de mise en file d'attente de messages, c'est-à-dire dans les applications qui doivent se remettre d'une perte de données.

Commandez les participants au modèle de conception

Dans une implémentation classique du modèle de commande, vous avez quatre composants: la commande, l'invocateur, le récepteur et le client. Les participants au modèle de conception de commande sont les suivants:

  • Commande - fournit une interface pour exécuter une opération
  • ConcreteCommand - étend l'interface de commande et implémente la méthode Execute
  • Client - instancie une classe ConcreteCommand
  • Invoker - informe la commande d'exécuter la demande
  • Receiver - contient la logique pour exécuter les opérations associées à la demande

Exemple de modèle de conception de commande en C #

Dans la section suivante, nous explorerons comment nous pouvons implémenter le modèle de conception de commande. Dans notre exemple, nous allons implémenter une calculatrice simple en utilisant les classes suivantes:

  • Command (classe de base abstraite Command)
  • SimpleCalculator (classe Receiver)
  • AddCommand (classe de commande concrète)
  • SubstractCommand (classe de commande concrète)
  • Commande de multiplication (classe de commande concrète)
  • DivideCommand (classe de commande concrète)
  • Invoker (classe Invoker)

Créer la classe de base abstraite Command en C #

Considérez la classe de base abstraite suivante nommée Command qui contient la déclaration de la méthode Execute.

Commande de classe abstraite publique

    {

        récepteur protégé SimpleCalculator;

        Commande publique (récepteur SimpleCalculator)

        {

            this.receiver = récepteur;

        }

        public abstract int Execute ();

    }

L'énumération suivante montre les opérations qui seront prises en charge dans notre calculatrice simple.

public enum CommandOption

    {

        Ajouter, soustraire, multiplier, diviser

    }

Créer la classe Receiver en C #

Voici une classe nommée SimpleCalculator. Cette classe agit en tant que récepteur et contient la définition des méthodes Add, Subtract, Multiply et Divide.

classe publique SimpleCalculator

    {

        int privé _x, _y;

        public SimpleCalculator (int a, int b)

        {

            _x = a;

            _y = b;

        }

        public int Add ()

        {

            return _x + _y;

        }

        public int Subtract ()

        {

            retourne _x - _y;

        }

        public int Multiplier ()

        {

            return _x * _y;

        }

        public int Divide ()

        {

            return _x / _y;

        }

    }

Créer les classes de commandes concrètes en C #

Les classes de commande concrètes étendent la classe de base abstraite Command et implémentent la méthode Execute comme indiqué ci-dessous.

 public class AddCommand: Command

    {

        privé SimpleCalculator _calculator;

        public AddCommand (calculatrice SimpleCalculator): base (calculatrice)

        {

            _calculator = calculatrice;

        }

        public override int Execute ()

        {

            return _calculator.Add ();

        }

    }

    public class SubtractCommand: Command

    {

        privé SimpleCalculator _calculator;

        public SubtractCommand (calculatrice SimpleCalculator):

        base (calculatrice)

        {

            _calculator = calculatrice;

        }

        public override int Execute ()

        {

            return _calculator.Subtract ();

        }

    }

    classe publique MultiplyCommand: Command

    {

        privé SimpleCalculator _calculator;

        public MultiplyCommand (calculatrice SimpleCalculator):

        base (calculatrice)

        {

            _calculator = calculatrice;

        }

        public override int Execute ()

        {

            return _calculator.Multiply ();

        }

    }

    public class DivideCommand: Commande

    {

        privé SimpleCalculator _calculator;

        public DivideCommand (calculatrice SimpleCalculator):

        base (calculatrice)

        {

            _calculator = calculatrice;

        }

        public override int Execute ()

        {

            return _calculator.Divide ();

        }

    }

Créer la classe Invoker en C #

L'extrait de code suivant illustre la classe Invoker. Il contient deux méthodes, SetCommand et Execute. Alors que SetCommand est utilisé pour affecter l'objet de commande à la référence de commande privée dans la classe Invoker, Execute est utilisé pour exécuter la commande.

    Invocateur de classe publique

    {

        Commande privée _command;

        public void SetCommand (commande de commande)

        {

            _command = commande;

        }

        public int Execute ()

        {

            return _command.Execute ();

        }

    }

Le modèle de conception de commande en action en C #

Enfin, l'extrait de code suivant illustre comment vous pouvez effectuer un calcul simple à l'aide de la classe SimpleCalculator.

static void Main (string [] args)

        {

            Calculatrice SimpleCalculator = nouveau SimpleCalculator (15, 3);

            var addCommand = new AddCommand (calculatrice);

            var substractCommand = new SubtractCommand (calculatrice);

            var multiplyCommand = new MultiplyCommand (calculatrice);

            var divideCommand = new DivideCommand (calculatrice);

            Invoker invoker = new Invoker ();

            invoker.SetCommand (addCommand);

            Console.WriteLine ("Le résultat est {0}", invoker.Execute ());

            invoker.SetCommand (substractCommand);

            Console.WriteLine ("Le résultat est {0}", invoker.Execute ());

            invoker.SetCommand (multiplyCommand);

            Console.WriteLine ("Le résultat est {0}", invoker.Execute ());

            invoker.SetCommand (divideCommand);

            Console.WriteLine ("Le résultat est {0}", invoker.Execute ());

            Console.ReadLine ();

        }

Le modèle de conception de commande prend en charge l'extensibilité et réduit le couplage existant entre l'invocateur et le récepteur d'une commande. Étant donné que la demande est encapsulée dans un objet autonome, vous pouvez paramétrer des méthodes avec différentes demandes, enregistrer les demandes dans une file d'attente et même prendre en charge les opérations pouvant être rétablies ou annulées.

-

Faites plus avec C #:

  • Comment travailler avec AutoMapper en C #
  • Quand utiliser une classe abstraite ou une interface en C #
  • Comment travailler avec des threads en C #
  • Comment utiliser l'ORM Dapper en C #
  • Comment implémenter le modèle de conception de référentiel en C #
  • Comment implémenter un simple logger en C #
  • Comment travailler avec des délégués en C #
  • Comment travailler avec les délégués Action, Func et Predicate en C #
  • Comment travailler avec log4net en C #
  • Comment travailler avec la réflexion en C #