क्या मैं अपने मामले के लिए रणनीति या कमांड पैटर्न का उपयोग करता हूं?

मेरे पास दो एल्गोरिदम हैं जिन्हें मैं कार्यान्वित कर रहा हूं:

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

एल्गोरिदम में क्या समान है:

  • दोनों "संक्षेप" एल्गोरिदम हैं जो इसके साथ आपूर्ति की जाती हैं इनपुट का अनुक्रम। खाते में क्या एल्गोरिदम थोड़ा भिन्न होता है एक विशेष मूल्य के लिए या नहीं। वे गणना में भी भिन्न होते हैं अनुक्रम के प्रति मान प्रदर्शन किया जाना चाहिए।
  • दोनों एल्गोरिदम को उसी ऑब्जेक्ट द्वारा संदर्भित किया जाता है (उदा। एक ' एंटीना ' जो ट्रांसमिशन या प्राप्त करने के लिए एल्गोरिदम का उपयोग करता है)।
  • दोनों मामलों में, मैं वेक्टर या मैट्रिक्स परिणाम को क्रमबद्ध करने में सक्षम होना चाहता हूं। इसके अलावा, मुझे पहले के जनरेशन से गणना किए गए (deserialized) वेक्टर/मैट्रिक्स मानों के साथ किसी भी एल्गोरिदम प्रारंभ करने में सक्षम होना चाहिए।

मैंने पहले रणनीति पैटर्न का उपयोग करके उपरोक्त को लागू करने का प्रयास किया, लेकिन जल्द ही मुझे एहसास हुआ कि अलग-अलग प्रकार/मूल्यों के कारण रणनीति पैटर्न सबसे अच्छा नहीं हो सकता है। और चीजों को और जटिल करने के लिए, मेरी ' एंटीना ' ऑब्जेक्ट किसी भी दिशा में किसी भी एल्गोरिदम का उपयोग कर सकती है:

class Antenna
{
    private AlgorithmParams _algorithm;
}

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

जो मुझे लगता है कि यह कई बार "प्रेषण" और "प्राप्त" की धारणा को डुप्लिकेट करता है (क्योंकि एल्गोरिदम , जो IAlgorithm लागू करता है, ने स्वयं को ' एल्गोरिदमैट्रांसमिट ' और '< कोड> एल्गोरिदममर्सिव 'यानी दिशा के आधार पर एक ही एल्गोरिदम के भीतर मामूली बदलाव)।

मैं एल्गोरिदम तर्क और धारावाहिक डेटा के बीच क्लीनर अलगाव भी लेना चाहता हूं।

मुझे इस पर आपकी राय सुनकर खुशी होगी। धन्यवाद !

0
जोड़ा संपादित
विचारों: 1

1 उत्तर

मेरे लिए रणनीति पैटर्न केवल ऑब्जेक्ट संरचना का उपयोग करने के अलावा कुछ भी नहीं है ताकि कक्षा में विभिन्न रणनीतियों का एक समूह इस्तेमाल किया जा सके और रन-टाइम में अंतर हो सके। यदि आप इनपुट मानों के आधार पर एंटेना कक्षा को रन-टाइम में अपना व्यवहार (एल्गोरिदम) बदलना चाहते हैं, तो आप अपने मामले में, रणनीति पैटर्न का उपयोग कर सकते हैं। यदि यह मामला है, एंटीना वर्ग में, आपके पास एक एल्गोरिदम इंटेरफेस को इंगित करने वाला एक आवृत्ति चर होता है, जो 4 वर्गों द्वारा प्राप्त होता है: AlgoATransmit, AlgoBTransmit, AlgoAReceive, और AlgoBReceive। इनमें से प्रत्येक 4 कक्षा वास्तविक एल्गोरिदम परिभाषित करेगी। फिर, आपको क्लाइंट क्लास की आवश्यकता होती है जो इनपुट मान प्रकारों की जांच करता है, और उपयुक्त एल्गोरिदम का उपयोग करने के लिए एंटीना सेट करता है।

जबकि मुझे नहीं लगता कि कमांड पैटर्न कैसे लागू किया जा सकता है, आपकी समस्या टेम्पलेट विधि पैटर्न के लिए भी एक अच्छा मामला हो सकता है और आप इसे रणनीति के पूरक में उपयोग कर सकते हैं। आप एक अमूर्त वर्ग के लिए क्या कर सकते हैं, चलिए इसे एब्स्ट्रैक्ट एल्गोरिदम कहते हैं, जिसमें "टेम्पलेट विधि" है जो अलग-अलग कार्यों को कॉल करके एल्गोरिदम के सामान्य प्रवाह को परिभाषित करता है। उपखंडों में इन कार्यों को ओवरराइड किया जाएगा, उदा। एल्गोरिदम, एल्गोरिदम बी।

टेम्पलेट विधि के अंदर "हुक" का उपयोग करके एंटीना की दिशा हल की जा सकती है। हुक मूल रूप से कार्य होते हैं जो उप-वर्गों में ओवरराइड करने के लिए वैकल्पिक होते हैं।

यहां एक साधारण नमूना कोड है। एंटीना ऑब्जेक्ट कंपोजिशन एंड स्ट्रैटेजी का उपयोग करता है, इसमें एक सार है जो सार एल्गोरिदम को इंगित करती है, जो 2 एल्गोरिदम द्वारा ली गई है। इस तरह, एल्गोरिदम की रूपरेखा एक ही स्थान पर निर्दिष्ट की जा सकती है, और प्रत्येक ठोस चरण उप-वर्गों में परिभाषित किया गया है। उम्मीद है कि यह मदद करता है और मुझे आशा है कि मैं आपकी समस्या को सही समझूंगा।

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
जोड़ा
आपके उत्तर के लिए बहूत बहूत धन्यवाद ! अगर मुझे गलत नहीं लगता है, तो क्या आपका सुझाव एंटीना को ट्रांसमिशन और प्राप्त करने के लिए उसी एल्गोरिदम प्रकार को लागू करने के लिए प्रतिबंधित नहीं करेगा? मेरे मॉडल में, एंटीना में ट्रांसमिशन के लिए एल्गोरिदम हो सकता है, लेकिन प्राप्त करने के लिए एल्गोरिदम बी। धन्यवाद।
जोड़ा लेखक alhazen, स्रोत
हाय alhazen, आप संचार और प्राप्त करने के बीच कैसे चुनते हैं? और वे एल्गोरिदम को कैसे प्रभावित करते हैं? क्या यह अल्गो या अल्गोबी में कोई अंतर है जब यह किसी भी दिशा को लागू करता है?
जोड़ा लेखक Son Do Lenh, स्रोत