मैंने अक्सर देखा (और कभी-कभी खुद लिखा) जैसे निर्माण:

if(A || B)
{
    var sharedValue = ...;
    if(A)
    {
      // do stuff with sharedValue
    }
    else
    {
      // do other stuff with sharedValue 
    }
}

वास्तविक उदाहरण:

switch (e.Key)
{
   /* 
    * Don't mind the switch, since it can be simply converted into:
    * if(e.Key == Key.Left || e.Key == Key.Right) { ... }
    */
   case Key.Left: 
   case Key.Right:
       var container = containerFromData(data);
       if (e.Key == Key.Left)
       {
          this.TryNavigateBackward(container);
       }
       else
       {
          this.TryNavigateForward(container);
       }
}

मैं वास्तव में महसूस करता हूं जैसे कि मैं कुछ याद कर रहा हूं, इसलिए इसका वर्णन करने के लिए एक बेहतर (सरल, कम क्रिया) तरीका होना चाहिए, लेकिन एक विचार के साथ नहीं आ सका। यह प्रश्न शायद प्रोग्रामिंग भाषा के लिए कुछ हद तक बाध्य है (मैं वर्तमान में सी # में हूं), लेकिन क्या वहां कोई निर्माण है, जो दिए गए उदाहरण को सरल बनाने में सक्षम है?

नोट: मुझे टर्नरी कंडीशनल ऑपरेटर a ? b : c के बारे में पता है, लेकिन यह (कम से कम C# में) केवल तभी काम करता है जब मान प्राप्त करें और उन्हें वेरिएबल में डाल दें। ऊपर दिया गया उदाहरण वास्तव में साझा मान के साथ भिन्न (शायद जटिल) चीजें करना करना चाहता है।

1
jlang 23 अक्टूबर 2018, 11:47

1 उत्तर

सबसे बढ़िया उत्तर

चूंकि मुझे कोई अन्य सुझाव नहीं दिख रहा है, मैं कुछ बाहर निकाल दूंगा और देखूंगा कि क्या वे वही हैं जो आप खोज रहे हैं।

सबसे पहले, यदि OOP तालिका में है, तो वंशानुक्रम इस प्रकार के साझा व्यवहार का प्रतिनिधित्व कर सकता है। आप जो करेंगे वह साझा, A-विशिष्ट और B-विशिष्ट व्यवहार Shared, ASpecific और BSpecific, जहां ASpecific और BSpecific, Shared से इनहेरिट करते हैं। फिर, यदि या तो A या B, आप क्रमशः ASpecific या BSpecific का एक उदाहरण स्पिन करते हैं, और फिर इसे Shared के उदाहरण के रूप में मानते हैं। . यदि आपके पास C, D, आदि स्थितियां हैं जो साझा चीज़ का उपयोग नहीं करती हैं, तो संभवतः आपके पास Base नामक एक और मूल वर्ग होगा और आपके पास CBase, DBase को Base से विरासत में मिला है, Shared को Base से विरासत में मिला है, और स्थिति के आधार पर एक उदाहरण स्पिन करें और परिणाम को Base के उदाहरण के रूप में मानें। .

दूसरा, साझा सामग्री की आवश्यकता होने पर आप ए-विशिष्ट और बी-विशिष्ट व्यवहारों को साझा विधि में पास करके नियंत्रण में उलटा उपयोग कर सकते हैं। आप इसके लिए या शुद्ध कार्यात्मक प्रोग्रामिंग के लिए ओओपी का उपयोग कर सकते हैं। उत्तरार्द्ध के साथ जा रहे हैं (चूंकि पूर्व उपरोक्त समाधान के समान है और शायद उतना अच्छा नहीं है), आपके पास एक shared फ़ंक्शन होगा जो फ़ंक्शन f को एक तर्क के रूप में लेता है। फ़ंक्शन f में एक हस्ताक्षर होगा जिसके लिए साझा ऑब्जेक्ट को पास करना आवश्यक है। फिर, यदि A, shared को एक फ़ंक्शन (पॉइंटर या अनाम इनलाइन) के साथ कॉल करें जो A- इसमें साझा की गई वस्तु के लिए विशिष्ट सामग्री; अन्यथा, यदि B, shared को उस फ़ंक्शन के साथ कॉल करें जो B करता है - इसमें साझा की गई वस्तु के लिए विशिष्ट सामग्री।

यदि आप वास्तव में केवल नेस्टिंग से बचना चाहते हैं, तो आप if (A || B) { … } सामान भी ला सकते हैं और इसे साझा कर सकते हैं जिसे घोषित किया गया है लेकिन उच्च दायरे में तत्काल नहीं किया गया है; फिर, बाद में, A और B को अलग-अलग जांचें और जानें कि उन मामलों में shared में पहले से आवश्यक सेटअप होगा।

1
Patrick87 26 अक्टूबर 2018, 12:56