आईएस (टाइप चेक) को कम करने के लिए पॉलिमॉर्फिज्म + ओवरलोडिंग का उपयोग करके इस विधि को कैसे सुधारें?

Question

उदाहरण

BaseClass MyBase() 
{ 
    public int Add(BaseClass next) 
    { 
     if (this is InheritedA && next is InheritedA) 
      return 1; 
     else if (this is InheritedA && next is InheritedB) 
      return 2; 
     else if (this is InheritedB && next is InheritedA) 
      return 3; 
     else if (this is InheritedB && next is InheritedB) 
      return 4;  
    } 
} 

जहां InheritedA के लिए, और InheritedB अपनी विरासत में मिला वर्ग हैं। वास्तव में, वहाँ और अधिक पारंपरिक रूप से प्राप्त कक्षाएं हैं, और आदेश और उसके संकार्य के प्रकार के आधार Add रिटर्न अलग परिणाम।

मैं पॉलिमॉर्फिज्म और ओवरलोडिंग का उपयोग करके इसे फिर से लिखने की सोच रहा हूं, हालांकि, यह जटिल हो जाता है, मुझे किसी भी प्रकार के प्रकार को हल करने के लिए एक सहायक विधि पेश करना है।

उदा।

InheritedA myA() 
{ 
    public override int Add(BaseClass next) 
    { 
     return next.AddTo(this); 
    } 
} 

अब मैं BaseClass में AddTo रखा, और साथ ही विरासत में मिला वर्ग में ओवरराइड कर दिया है।

InheritedA myA() 
{ 
    public override int AddTo(InheritedA next) { return 1; } 
    public override int AddTo(InheritedB next) { return 3; } 
} 

BaseClass myBase() 
{ 
    public abstract int Add(BaseClass next); 
    public abstract int AddTo(InheritedA next); 
    public abstract int AddTo(InheritedB next); 
} 

क्या ऐसा करने का कोई बेहतर तरीका है?

Answer 1

जैसा कि टिप्पणियों में सुझाव दिया गया था, यदि आप प्रत्येक व्युत्पन्न के लिए निरंतर मूल्य आवंटित करने में सक्षम हैं, तो आप Value नामक वर्चुअल प्रॉपर्टी के साथ यहां एक बहुत अधिक क्लीनर कार्यान्वयन कर सकते हैं या इसी तरह अतिरिक्त के लिए इस्तेमाल किया।

यह मानते हुए कि नहीं है एक विकल्प है, तो आप मान प्रत्येक संयोजन के लिए बताए रहे हैं वर्णन करने के लिए विचार करने के लिए पूर्व की गणना आधार वर्ग स्तर पर परिणामों चाह सकते हैं। यह टूट सकता है और वर्गों के सेट के रूप में त्रुटि प्रवण और थकाऊ हो सकता है, इसलिए मैं केवल इस पर विचार करने का सुझाव दूंगा यदि आप एक बहुत छोटे सेट को बनाए रखने की उम्मीद करते हैं।

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

public class BaseClass 
{ 
    private static readonly Dictionary<int, int> addResults = new Dictionary<int, int>(); 

    static BaseClass() 
    { 
    addResults.Add(CreateKey(typeof(ChildA), typeof(ChildA)), 1); 
    addResults.Add(CreateKey(typeof(ChildA), typeof(ChildB)), 2); 
    addResults.Add(CreateKey(typeof(ChildB), typeof(ChildA)), 3); 
    addResults.Add(CreateKey(typeof(ChildB), typeof(ChildB)), 4); 
    } 

    public static int CreateKey(Type a, Type b) 
    { 
    return (String.Concat(a.Name, b.Name).GetHashCode()); 
    } 

    public int Add(BaseClass next) 
    { 
    var result = default(int); 

    if (!addResults.TryGetValue(CreateKey(this.GetType(), next.GetType()), out result)) 
    { 
     throw new ArgumentOutOfRangeException("Unknown operand combination"); 
    } 

    return result; 
    } 
} 

public class ChildA : BaseClass {} 
public class ChildB : BaseClass {} 

Answer 2

पैटर्न आप कार्यान्वित कर रहे हैं डबल आभासी प्रेषण कहा जाता है।

एक एकल आभासी प्रेषण चुनता है जो विधि रन-टाइम प्रकार रिसीवर के और तर्कों की संकलन समय प्रकार के आधार पर कॉल करने के लिए। यह एक पारंपरिक आभासी प्रेषण है:

abstract class Animal {} 
class Tiger : Animal {} 
class Giraffe : Animal {} 
class B 
{ 
    public virtual void M(Tiger x) {} 
    public virtual void M(Animal x) {} 
} 
class D : B 
{ 
    public override void M(Tiger x) {} 
    public override void M(Animal x) {} 
} 
... 
B b = whatever; 
Animal a = new Tiger(); 
b.M(a); 

किस विधि को बुलाया जाता है? B.M(Tiger) और D.M(Tiger) नहीं चुने गए हैं; हम तर्क है, जो पशु है की संकलन समय प्रकार के आधार पर उन्हें अस्वीकार करते हैं। लेकिन हम पर है कि क्या whatevernew B() या new D() है आधारित रनटाइम पर B.M(Animal) या D.M(Animal) कॉल करने के लिए कि क्या चुनें।

डबल आभासी प्रेषण चुनता है जो विधि दो बातें के क्रम प्रकार के आधार पर कॉल करने के लिए।यदि सी # समर्थित डबल आभासी प्रेषण, जो यह नहीं करता है, तो रनटाइम प्रेषण B.M(Tiger) या D.M(Tiger) पर जाएगा, भले ही तर्क का संकलन-समय प्रकार पशु है।

सी # 4 हालांकि गतिशील प्रेषण का समर्थन करता है। आप

dynamic b = whatever; 
dynamic a = new Tiger(); 
b.M(a); 

कहना तो हैं एम के विश्लेषण पूरी तरह से क्रम पर किया जाएगा b और a के क्रम प्रकार का उपयोग कर। यह काफी धीमा है, लेकिन यह काम करता है।

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