👨‍🏫 🧗🏾 👩🏽‍✈️ एकाधिक शाखाएँ और नियम टेम्पलेट 👩🏿‍🏭 🏩 🚴

नमस्कार प्रिय हब्बरचित्तेली। इस लेख में, मैं एक छोटे और सरल, लेकिन उपयोगी टेम्पलेट के बारे में ज्ञान साझा करना चाहूंगा, जो आमतौर पर पुस्तकों के बारे में नहीं लिखा जाता है (शायद इसलिए कि यह "टीम" टेम्पलेट का एक विशेष मामला है)। यह रूल्स पैटर्न है। संभवतः कई लोगों के लिए वह बहुत परिचित होगा, लेकिन किसी को उसे जानने के लिए दिलचस्पी होगी।

मुद्दे का सार

बहुत बार, जटिल तर्क विकसित करते समय, नेस्टेड इफ्स का एक पेड़ पैदा होता है, जो कि उदाहरण के लिए, इस तरह दिख सकता है:

भयानक कोड

public double CalculateSomething(Condition condition) { //   if(condition.First...) ... //   if(condition.Second...) ... //    if(condition.AnotherFirst...) { //      if(condition.First) ... else... } //    if(condition.AnotherSecond...) { //      if(condition.Second) ... else... } //    if(condition.YetAnotherFirst) { //... if(condition.AnotherFirst && condition.Second) ... else { ... } } // O_o }

क्या वह परिचित है? तो यहां क्या समस्याएं हैं?

समस्या 1: चक्रवाती जटिलता बढ़ाना। सीधे शब्दों में कहें तो साइक्लोमैटिक कॉम्प्लेक्सिटी, लॉजिक ऑपरेटर्स को ध्यान में रखते हुए आईएफ और लूप्स के नेस्टिंग की गहराई है। कोड विश्लेषण उपकरण आपको कोड के सभी वर्गों के लिए इस पैरामीटर का मूल्यांकन करने की अनुमति देता है। यह माना जाता है कि किसी विशेष खंड के लिए साइक्लोमैटिक जटिलता का पैरामीटर इस समस्या के 10. से अधिक नहीं होना चाहिए, निम्नलिखित बढ़ता है।

समस्या 2: नया तर्क जोड़ना। समय के साथ और नई स्थितियों के जुड़ने के बाद, यह समझना मुश्किल हो जाता है कि नए तर्क कहाँ और कैसे जोड़े जाएँ।

समस्या 3: कोड दोहराव। यदि स्थिति पेड़ शाखा है, तो कभी-कभी स्थिति से छुटकारा पाना असंभव होता है जब एक ही कोड कई शाखाओं में मौजूद होता है।

यह वह जगह है जहां "नियम" टेम्पलेट बचाव के लिए आता है। इसकी संरचना बहुत सरल है:

Uml आरेख संरचना

यहां, इवैल्यूएटर वर्ग में आईआरयूएल इंटरफ़ेस के कार्यान्वयन का एक संग्रह है। मूल्यांकनकर्ता नियमों को निष्पादित करता है और यह तय करता है कि परिणाम प्राप्त करने के लिए किस नियम का उपयोग किया जाना चाहिए। यह समझने के लिए कि यह कैसे काम करता है और कोड में दिखता है, C # में एक छोटा उदाहरण देखें।

एक उदाहरण है। पासा खेल (जैसे "ताली")

खेल नियम:

खिलाड़ी एक ही समय में 5 पासा रोल करता है, और उनके संयोजन के आधार पर एक निश्चित मात्रा में अंक प्राप्त करता है।
संयोजन निम्नानुसार हो सकते हैं:
1 XXXX - 100 अंक
5 XXXX - 50 अंक
1 1 1 XX - 1000 अंक
2 2 2 XX - 200 अंक
3 3 3 XX - 300 अंक
4 4 4 XX - 400 अंक
5 5 5 XX - 500 अंक
6 6 6 XX - 600 अंक

संयोजनों के उदाहरण:
[1,1,1,5,1] - 1150 अंक
[2,3,4,6,2] - 0 अंक
[3,4,5,3,3] - 350 अंक

बेशक, उनमें से सभी अलग-अलग हो सकते हैं, और कई और भी हो सकते हैं, लेकिन बाद में और भी बहुत कुछ।

एक बार करो! कोई पैटर्न नहीं।

आइए, "नियम" टेम्पलेट को लागू किए बिना खेल के तर्क का वर्णन करने का प्रयास करें, ठीक उसी तरह जैसे हम 8 वीं कक्षा में एक सूचनात्मक पाठ में लिखते हैं (स्वाभाविक रूप से, टिप्पणियों के साथ हमारे बुरे कोड की आपूर्ति किए बिना - जिनकी उन्हें आवश्यकता है!)

बुरा, दुष्ट खेल कक्षा

 public class Game { public int Score(int[] roles) { int score = 0; for(int i=1; i<7; i++) { int count = CountDiceWithValue(roles, i); count = ScoreSetOfN(count, GetSetSize(i), SetSetScore(i), ref score); score += count * GetSingleDieScore(i); } return score } private int GetSingleDieScore(int val) { if(val==1) return 100; if(val==5) return 50; return 0; } private int GetSetScore(int val) { if(val==1) return 1000; return val*100; } private int GetSetSize(int val) { return 3; } private int ScoreSetOfN(int count, int setSize, int setScore, ref int score) { if(count>=setSize) { score += setScore; return count - 3; } return count; } private int CountDiceWithValue(int[] roles, int val) { int count = 0; foreach (int r in roles) { if (r == val) count++; } return count; } }

दो दो! नियम जोड़ना? इकाई परीक्षण।

ऐसा लगता है कि कोड की 50 लाइनें बहुत छोटी हैं। लेकिन अगर खेल के नियमों को बदल दिया जाए और जोड़ दिया जाए तो क्या होगा?
उदाहरण के लिए, हम पासा के विभिन्न संयोजनों के लिए नियम जोड़ेंगे:

1 1 1 1 X - 2000
1 1 1 1 1 - 4000
1 2 3 4 5 - 8000
2 3 4 5 6 - 8000
AABBX - 4000
और इसी तरह।

इस मामले में, कोड बहुत भ्रमित होने का जोखिम चलाता है। इससे बचने के लिए, हम "नियम" टेम्पलेट का उपयोग करके कोड को फिर से लिखते हैं।
(यहां, मुझे यह भी कहना चाहिए कि रिफैक्टरिंग करने से पहले आपको यूनिट परीक्षणों के साथ सभी मामलों को कवर करने की आवश्यकता है, उनके महत्व और कोड रीफैक्टरिंग की आवश्यकता के बारे में सोचना)

तीन करो! "नियम" टेम्पलेट लागू करें

1. Eval पद्धति के साथ IRule इंटरफ़ेस को परिभाषित करें, जो पासा के एक विशिष्ट सेट के लिए अंकों की संख्या का अनुमान लगाने के लिए आवश्यक है।

IRule.cs

 public interface IRule { ScoreResult Eval(int[] dice); }

2. एक वर्ग RuleSet बनाएं, जो नियमों के सेट, एक नियम को जोड़ने के लिए तर्क, और सबसे अच्छा नियम चुनने के लिए तर्क को निर्धारित करेगा जो क्यूब्स के इस सेट पर लागू किया जा सकता है:

RuleSet.cs

 public class RuleSet { //  private List<IRule> _rules = new List<IRule>(); //  public void Add(IRule rule) { _rules.Add(rule); } //   - ,      public IRule BestRule(int[] dice) { ScoreResult bestResult = new ScoreResult(); foreach(var rule in _rules) { var result = rule.Eval(dice); if(result.Score > bestResult.Score) { bestResult = result; } return bestResult.RuleUsed; } } }

3. बेशक, एक छोटा सहायक वर्ग

ScoreResult.cs

 public class ScoreResult { //   public int Score {get;set;} //    (       ) public int[] DiceUsed {get;set;} //   ,  ,     (  BestRule) public IRule RuleUsed {get;set;} }

4. और नियमों को स्वयं परिभाषित करें।

ConcreteRules.cs

 //    public class SingleDieRule : IRule { private readonly int _value; private readonly int _score; public SingleDieRule(int dieValue, int score) { _dieValue = dieValue, _score = score } //   -      public ScoreResult Eval(int[] dice) { //- var result = new ScoreResult(); //    (   ) -    result.DiceUsed = dice.Where(d=>d == dieValue).ToArray(); //   result.Score = result.DiceUsed.Count() * _score; //  -       result.RuleUsed = this; return result; } } //

5. हमारे मामले में, योजना से Evaluator वर्ग Game वर्ग होगा, इसमें नियमों को जोड़ने के तर्क और स्कोरिंग के लिए तर्क के अलावा लगभग कुछ भी नहीं होगा

Game.cs - मूल्यांकनकर्ता

 public class Game { private readonly RuleSet _ruleSet = new RuleSet(); public Game(bool useAllRules) { //  _ruleSet.Add(new SingleDieRule(1,100)); _ruleSet.Add(new SingleDieRule(5,50)); _ruleSet.Add(new TripleDieRule(1,1000)); for(int i=2; i<7; i++) { _ruleSet.Add(new TripleDieRule(i, i*100)); } //  if(useAllRules) { _ruleSet.Add(new FourOfADieRule(1,2000)); _ruleSet.Add(new SetOfADieRule(5,1,4000)); _ruleSet.Add(new StraightRule(8000)); _ruleSet.Add(new TwoPairsRule(6000)); for(int i=2; i<7; i++) { _ruleSet.Add(new FourOfADieRule(i,i*200)); _ruleSet.Add(new SetOfADieRule(i,i*400)); //... } } } //       public void AddScoringRule(IRule rule) { _ruleSet.Add(rule); } //  public int Score(int[] dice) { int score = 0; var remainingDice = new List<int>(dice); var bestRule = _ruleSet.BestRule(remainingDice.ToArray()); //             while(bestRule!=null) { var result = bestRule.Eval(remainingDice.ToArray()); foreach(var die in result.DiceUsed) { remainingDice.Remove(die); } score+=result.Score; bestRule = _ruleSet.BestRule(remainingDice.ToArray()); } return score; } }

हुर्रे! समस्या हल हो गई है! अब प्रत्येक वर्ग इस बात में लगा हुआ है कि यह कैसा होना चाहिए, चक्रीय जटिलता नहीं बढ़ती है,
और नए नियम आसानी से और सरलता से जोड़े जाते हैं। नियम नियम श्रेणी का उपयोग करके अब एक नियम का RuleSet किया RuleSet , जिसमें नियमों का एक सेट होता है, और नियमों को Game वर्ग द्वारा जोड़ा और स्कोर किया जाता है।

आपको याद रखने की क्या आवश्यकता है?

नियम-आधारित तर्क वाले प्रोग्राम को डिज़ाइन करते समय, निम्नलिखित मुद्दों को ध्यान में रखना उपयोगी होता है:
- क्या नियमों को केवल व्यवस्था के संबंध में पढ़ा जाना चाहिए ताकि इसकी स्थिति में बदलाव न हो?
- क्या नियमों के बीच निर्भरता होनी चाहिए? क्या यह उस आदेश पर ध्यान देने के लायक है जिसमें नियमों को निष्पादित किया जाता है, मामले में जब एक नियम को काम करने के लिए दूसरे नियम के परिणाम की आवश्यकता हो सकती है।
- क्या नियम प्रवर्तन आदेश को कड़ाई से परिभाषित किया जाना चाहिए?
- क्या नियमों के क्रियान्वयन में प्राथमिकताएं होनी चाहिए?
- क्या अंतिम उपयोगकर्ताओं को नियमों को संपादित करने की अनुमति दी जानी चाहिए?
और कई अन्य।

बिजनेस रूल्स इंजन के बारे में कुछ शब्द

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

सारांश

1) हम "नियम" टेम्पलेट का उपयोग करते हैं जब शर्तों और शाखाओं की जटिलता से छुटकारा पाने के लिए आवश्यक होता है
2) प्रत्येक नियम और उसके वर्गों में इसके प्रभावों का तर्क रखो
3) एक अलग वर्ग में नियमों के चयन और प्रसंस्करण को अलग करें - मूल्यांकनकर्ता
4) हम जानते हैं कि व्यापार तर्क के लिए तैयार "इंजन" समाधान हैं

आपके ध्यान के लिए बहुत बहुत धन्यवाद, मुझे आशा है कि इस प्रशिक्षण सामग्री के मेरे रचनात्मक संशोधन से किसी को मदद मिलेगी।
* इस लेख के लिए प्रेरणा का स्रोत स्टीव स्मिथ द्वारा pluralsight.com पर "डिजाइन पैटर्न" पाठ्यक्रम से "नियम पैटर्न" सबक था ।

एकाधिक शाखाएँ और नियम टेम्पलेट