Est-ce que j'utilise la stratégie ou le modèle de commande pour mon cas?

J'ai deux algorithmes que j'implémente:

  • AlgorithmA which works with Vector values and
  • AlgorithmB which works with Matrix values

Ce que les algorithmes ont en commun:

  • Les deux sont des algorithmes de "sommation" qui sont fournis avec le même séquence d'entrées. Les algorithmes varient légèrement pour savoir s'il faut tenir compte pour une valeur particulière ou non. Ils varient également dans le calcul de être effectué par valeur de la séquence.
  • Les deux algorithmes sont référencés par le même objet (par exemple une ' Antenna ' qui utilise un algorithme pour la transmission ou la réception).
  • Dans les deux cas, je veux pouvoir sérialiser le résultat Vector ou Matrix. De plus, je devrais être capable d'initialiser n'importe lequel des algorithmes avec des valeurs vectorielles/matricielles (désérialisées) calculées à partir d'une génération antérieure.

J'ai d'abord essayé de mettre en œuvre ce qui précède en utilisant le modèle de stratégie, mais je me suis vite rendu compte que le modèle de stratégie pourrait ne pas être le meilleur en raison des différents types/valeurs. Et pour compliquer davantage les choses, mon objet ' Antenna ' pourrait utiliser n'importe lequel des algorithmes dans les deux sens:

class Antenna
{
    private AlgorithmParams _algorithm;
}

class AlgorithmParams
{
     private IAlgorithm _transmit;
     private IAlgorithm _receive;
}   

que je pense qu'il duplique la notion de "transmettre" et de "recevoir" plusieurs fois (parce que AlgorithmA , qui implémente IAlgorithm, a lui-même dérivé les types ' AlgorithmATransmit ' et '< code> AlgorithmAReceive 'c'est-à-dire de légères variations dans le même algorithme en fonction de la direction).

Je voudrais aussi avoir une séparation plus nette entre la logique de l'algorithme et les données sérialisées.

Je serais heureux d'entendre vos opinions à ce sujet. Merci !

0

1 Réponses

Pour moi, le modèle Strategy n'est rien de plus que l'utilisation de la composition d'objet pour permettre l'utilisation d'un ensemble de stratégies différentes dans une classe ET échangées en cours d'exécution. Dans votre cas, vous pouvez utiliser le modèle Strategy si vous voulez que la classe Antenna modifie son comportement (l'algorithme) en cours d'exécution, en fonction des valeurs d'entrée. Si c'est le cas, dans la classe Antenna, vous avez une variable d'instance pointant vers une AlgorithmInterface, qui est dérivée par 4 classes: AlgoATransmit, AlgoBTransmit, AlgoAReceive, et AlgoBReceive. Chacune de ces 4 classes définirait les algorithmes réels. Ensuite, vous avez besoin d'une classe client qui vérifie les types de valeur d'entrée et définissez l'Antenne pour utiliser l'algorithme approprié.

Bien que je ne vois pas comment le motif de commande peut être appliqué, votre problème peut également être un bon cas pour le modèle de méthode de modèle et vous pouvez l'utiliser en complément de la stratégie. Ce que vous pouvez faire est d'avoir une classe abstraite, appelons-la AbstractAlgorithm, qui a une "méthode de modèle" qui définit le flux commun des algorithmes en appelant des fonctions séparées. Ces fonctions seront remplacées dans les sous-classes, par ex. AlgorithmeA, AlgorithmeB.

La direction de l'antenne peut être résolue en utilisant des «crochets» dans la méthode du gabarit. Les hameçons sont essentiellement des fonctions facultatives à remplacer dans les sous-classes.

Voici un exemple de code simple. Antenna utilise la composition et la stratégie d'objet, a une variable pointant vers l'algorithme abstrait, qui est dérivé par 2 algorithmes. De cette façon, le contour des algorithmes peut être spécifié à un endroit, et chaque étape concrète est définie dans les sous-classes. J'espère que ça aide et j'espère avoir bien compris votre problème.

class Antenna {
    private AbstractAlgorithm algo;
    void SetAlgo(AbstractAlgorithm newAlgo) {
        algo = newAlgo;
    }
}

class AbstractAlgorithm {

    //this is the template method
    void runAlgo() {   
          step1();        //step1 and step2 are two common steps for both algorithms
          step2();
          if (isMatrixValue())
             step3();            //a hook, only AlgoB will override it.
          if (isTransmitting())
             step4();            //a hook, use for transmit
          else if (isReceiving())
             step5();            //a hook, use for receive

    }

    abstract void step1();
    abstract void step2();
    boolean isMatrixValue() {
         return false;         //default value, to not run step3
    }

}

class AlgorithmA {

    void step1() {
         //some implementation
    }
    void step2() {
         //some implementation
    }

    //use the default false value for isMatrixValue(), not to run step3


}


class AlgorithmB {

    void step1() {
         //some implementation
    }
    void step2() {
         //some implementation
    }
    void step3() {
         //some implementation
    }
    boolean isMatrixValue() {
         return true;         //return true and override step3
    }

}
0
ajouté
Merci beaucoup pour votre réponse ! Si je ne me trompe pas, votre suggestion ne restreindrait-elle pas l'antenne pour implémenter le même type d'algorithme pour l'émission et la réception? Dans mon modèle, une antenne peut avoir AlgorithmA pour la transmission, mais AlgorithmB pour la réception. Merci.
ajouté l'auteur alhazen, source
salut alhazen, comment choisissez-vous entre transmettre et recevoir? et comment affectent-ils les algorithmes? Y a-t-il une différence entre AlgoA et AlgoB quand il implémente l'une ou l'autre direction?
ajouté l'auteur Son Do Lenh, source