Folosesc strategia sau modelul de comandă pentru cazul meu?

Am doi algoritmi pe care îi pun în aplicare:

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

Ceea ce au în comun algoritmi:

  • Ambii sunt algoritmi de "sumare" care sunt furnizați cu aceiași algoritmi secvență de intrări. Algoritmii variază ușor dacă trebuie să contabilizăm pentru o anumită valoare sau nu. Ele variază de asemenea în calcul la să fie efectuată pe valoarea din secvență.
  • Ambii algoritmi sunt menționați de același obiect (de exemplu, un " Antena " care utilizează un algoritm pentru transmitere sau primire).
  • În ambele cazuri, vreau să pot serializa rezultatul Vector sau Matrix. În plus, ar trebui să pot inițializa oricare dintre algoritmii cu valori vectoriale/matrice (deserializate) calculate dintr-o generație anterioară.

Am încercat mai întâi implementarea celor de mai sus folosind modelul de strategie, dar în curând mi-am dat seama că modelul strategiei ar putea să nu fie cel mai bun datorită tipurilor/valorilor diferite. Și pentru a complica lucrurile, obiectul meu Antenna 'ar putea folosi oricare dintre algoritmi în ambele direcții:

class Antenna
{
    private AlgorithmParams _algorithm;
}

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

care simt că duplică noțiunea de "transmite" și "primi" de mai multe ori (deoarece AlgorithmA , care implementează IAlgorithm, ea însăși a derivat tipurile AlgorithmATransmit code> AlgorithmAReceive ", adică variații ușoare în cadrul aceluiași algoritm în funcție de direcție).

De asemenea, aș dori să am o separare mai curată între logica algoritmului și datele serializate.

Aș fi bucuros să vă aud opiniile în legătură cu acest lucru. Mulțumiri !

0

1 răspunsuri

Modelul de Strategie pentru mine nu este altceva decât utilizarea compoziției obiectului pentru a permite o grămadă de strategii diferite să poată fi utilizate într-o clasă AND schimbată în timpul run-time. În cazul dvs., puteți utiliza modelul de strategie, dacă doriți ca clasa Antenă să-și schimbe comportamentul (algoritmul) în timpul execuției, pe baza valorilor de intrare. Dacă acesta este cazul, în clasa Antenă, aveți o variabilă de instanță care indică o AlgorithmInterface, care este derivată din 4 clase: AlgoATransmit, AlgoBTransmit, AlgoAReceive și AlgoBReceive. Fiecare dintre aceste 4 clase ar defini algoritmii reali. Apoi, aveți nevoie de o clasă client care verifică tipurile de valori de intrare și setați Antena să utilizeze algoritmul corespunzător.

Deși nu văd cum se poate aplica modelul de comandă, problema dvs. ar putea fi, de asemenea, un caz bun pentru modelul Metodă șablon și îl puteți utiliza în completare cu strategia. Ceea ce puteți face este să aveți o clasă abstractă, să o numim AbstractAlgorithm, care are o "metodă șablon" care definește fluxul comun al algoritmilor apelând funcții separate. Aceste funcții vor fi suprascrise în subclasele, de ex. AlgoritmulA, AlgoritmulB.

Direcția Antenei poate fi rezolvată prin utilizarea "cârligelor" din interiorul metodei șablonului. Cârligele sunt, în principiu, funcții care sunt opționale pentru suprascrierea în subclase.

Iată un simplu exemplu de cod. Antena utilizează Object Composition and Strategy, are o variabilă care indică algoritmul abstract, care este derivat de la 2 algoritmi. În acest fel, conturul algoritmilor poate fi specificat într-un singur loc, iar fiecare etapă concretă este definită în subclasele. Sper că vă ajută și sper că v-am înțeles corect problema.

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
adăugat
Vă mulțumim mult pentru răspunsul dvs.! Dacă nu mă înșel, sugestia dvs. nu ar restricționa antena să implementeze același tip de algoritm atât pentru transmisie cât și pentru recepție? În modelul meu, o antenă poate avea AlgoritmA pentru transmitere, dar AlgorithmB pentru a primi. Mulțumiri.
adăugat autor alhazen, sursa
hi alhazen, cum alegeți între transmitere și primire? și cum afectează algoritmii? există vreo diferență fie în AlgoA, fie în AlgoB atunci când implementează oricare direcție?
adăugat autor Son Do Lenh, sursa