सी # कक्षा पदानुक्रम में गहरी प्रतिलिपि/क्लोन विधियां - क्या मुझे हर जगह एक ठोस कार्यान्वयन की आवश्यकता है?

Question

चलो कहते हैं कि मैं निम्नलिखित वर्ग पदानुक्रम है (आधार इंटरफ़ेस शामिल है) करते हैं:

IAction -> (abstract) BaseAction -> (concrete) ImmediateAction -> (concrete) MovementAction 

अब मान लें कि IAction एक विधि को उजागर करता है चलो (ठीक है, वास्तव में एक अलग इंटरफेस है कि IAction औजार लेकिन चीजों को सरल यहां रहने देती हैं, करता है!) :

// Returns a new IAction instance deep copied from the current instance. 
IAction DeepClone(); 

अभी तक अच्छा है? हम अपने गहरे प्रतिलिपि विधि है, और ImmediateAction कुछ गुण है कि यह तो यह न केवल DeepClone() के एक कार्यान्वयन प्रदान करेगा कॉपी किया चाहता है, लेकिन एक प्रति के साथ-साथ निर्माता:

//Base Action implementation 
protected BaseAction(BaseAction old) 
{ 
    this.something = old.something; 
} 

//Immediate Action Implementation 
protected ImmediateAction(ImmediateAction old) 
    : base(old) 
{ 
    this.anything = old.anything; 
} 

public IAction DeepClone() 
{ 
    return new ImmediateAction(this); 
} 

अब मान लें कि MovementAction नहीं है चलो इसके अंदर कुछ भी जो DeepClone() में प्रासंगिक है, इसलिए यह विधि या प्रतिलिपि कन्स्ट्रक्टर को लागू नहीं करता है। - जो एक नई ImmediateAction को दर्शाता है MovementActionDeepClone() को लागू नहीं करता, इसलिए ImmediateAction.DeepClone() बजाय कहा जाता है,

IAction x = new MovementAction(); 
IAction y = x.DeepClone(); 

//pleaseBeTrue is false 
bool pleaseBeTrue = y is MovementAction; 

अब, मैं समझ यहाँ क्या हो रहा है:

समस्या यह है कि मैं आ रही है यह है। इसलिए, ऊपर दिए गए उदाहरण में y का प्रकार MovementAction के बजाय ImmediateAction है।

तो, इस लंबी प्रस्तुति के बाद, मेरा प्रश्न यह है: इस प्रकार की स्थिति के लिए सबसे अच्छा अभ्यास क्या है? क्या मैं अटक गया हूँ? क्या मैं DeepClone() विधि लागू करने के लिए पदानुक्रम के साथ प्रत्येक वर्ग के लिए कोई फर्क नहीं पड़ता? क्या पैटर्न मैं यहां गलत उपयोग कर रहा हूं, और बेहतर तरीका है?

एक अंतिम नोट: यदि संभव हो तो मैं प्रतिबिंब से बचना चाहूंगा।

Answer 1

का उपयोग कर, लेकिन साझा कार्यान्वयन एक विस्तार विधि का उपयोग कर सकते हैं और वृद्धिशील क्लोनिंग

public static class DeepCopyExt 
{ 
    public static T DeepCopy<T>(this T item) 
     where T : ThingBase, new() 
    { 
     var newThing = new T(); 
     item.CopyInto(newThing); 
     return newThing; 
    } 
} 

public abstract class ThingBase 
{ 
    public int A { get; set; } 

    public virtual void CopyInto(ThingBase target) 
    { 
     target.A = A; 
    } 
} 

public class ThingA : ThingBase 
{ 
} 

public class ThingB : ThingA 
{ 
    public int B { get; set; } 

    public override void CopyInto(ThingBase target) 
    { 
     var thingB = target as ThingB; 

     if(thingB == null) 
     { 
      throw new ArgumentException("target is not a ThingB"); 
     } 

     thingB.B = B; 
     base.CopyInto(thingB); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var b = new ThingB 
     { 
      A = 1, 
      B = 3 
     }; 

     //c is ThingB 
     var c = b.DeepCopy(); 

     var b1 = new ThingA 
     { 
      A = 1, 
     }; 

     //c1 is ThingA 
     var c1 = b1.DeepCopy(); 

     Debugger.Break(); 
    } 
} 

Answer 2

आमतौर पर आपको ठोस वर्गों में अपनी क्लोन विधि को लागू करने की आवश्यकता होगी। वास्तव में इस कोड को आप पोस्ट अगर ImmediateAction संकलन नहीं होगा सार है जैसे आप शीर्ष पर कहा:

return new ImmediateAction(this); 

Answer 3

तो हाँ, आप दो विकल्प हैं:

• या तो DeepClone (लागू) हर बार और विवरण (सूची बिल्कुल नहीं से साझा की गई गुण)
• या प्रयोग 'जल्दी & गंदा' प्रतिबिंब