C # में, कक्षा में कार्यक्षमता जोड़ने (गहरी) कॉपी करने का पसंदीदा तरीका क्या है? एक प्रतिलिपि निर्माता को लागू करना चाहिए, या बल्कि से निकाले जाते हैं ICloneableऔर लागू Clone()विधि?
टिप्पणी : मैंने कोष्ठक के भीतर "गहरा" लिखा क्योंकि मुझे लगा कि यह अप्रासंगिक था। जाहिरा तौर पर अन्य लोग असहमत हैं, इसलिए मैंने पूछा कि क्या एक कॉपी कंस्ट्रक्टर / ऑपरेटर / फंक्शन को यह स्पष्ट करने की आवश्यकता है कि कौन सा संस्करण इसे लागू करता है ।
जवाबों:
आपको इससे व्युत्पन्न नहीं होना चाहिए ICloneable।
कारण यह है कि जब Microsoft ने .net फ्रेमवर्क डिज़ाइन किया था, तो उन्होंने कभी भी यह निर्दिष्ट नहीं किया कि क्या Clone()विधि ICloneableगहरी या उथली क्लोन होनी चाहिए, इस प्रकार इंटरफ़ेस शब्दार्थ रूप से टूट गया है क्योंकि आपके कॉलर्स को यह पता नहीं चलेगा कि कॉल गहरी होगी या उथली क्लोन वस्तु।
इसके बजाय, आप अपने खुद के परिभाषित करना चाहिए IDeepCloneable(और IShallowCloneable) के साथ इंटरफेस DeepClone()(और ShallowClone()) तरीकों।
आप दो इंटरफेस को परिभाषित कर सकते हैं, एक जेनेरिक पैरामीटर के साथ जोरदार टाइपिंग क्लोनिंग का समर्थन करने के लिए और एक जब आप विभिन्न प्रकार की क्लोन करने योग्य वस्तुओं के संग्रह के साथ काम कर रहे हैं तो कमजोर टाइप किए गए क्लोनिंग की क्षमता रखने के लिए:
public interface IDeepCloneable
{
object DeepClone();
}
public interface IDeepCloneable<T> : IDeepCloneable
{
T DeepClone();
}जिसे आप इस तरह लागू करेंगे:
public class SampleClass : IDeepCloneable<SampleClass>
{
public SampleClass DeepClone()
{
// Deep clone your object
return ...;
}
object IDeepCloneable.DeepClone()
{
return this.DeepClone();
}
}आम तौर पर मैं एक कॉपी कंस्ट्रक्टर के विपरीत वर्णित इंटरफेस का उपयोग करना पसंद करता हूं, इससे इरादे बहुत स्पष्ट रहते हैं। एक कॉपी कंस्ट्रक्टर को संभवतः एक गहरा क्लोन माना जाएगा, लेकिन यह निश्चित रूप से एक IDPClonable इंटरफ़ेस का उपयोग करते हुए एक स्पष्ट इरादे के रूप में नहीं है।
यह .net फ्रेमवर्क डिज़ाइन दिशानिर्देशों और ब्रैड अब्राम्स के ब्लॉग पर चर्चा की गई है
(मुझे लगता है कि यदि आप एक आवेदन पत्र लिख रहे हैं (एक रूपरेखा / पुस्तकालय के विपरीत) तो आप यह सुनिश्चित कर सकते हैं कि आपकी टीम के बाहर कोई भी आपके कोड को कॉल नहीं कर रहा है, यह इतना मायने नहीं रखता है और आप एक अर्थ का अर्थ बता सकते हैं "डीपक्लोन" .net ICloneable इंटरफ़ेस के लिए, लेकिन आपको यह सुनिश्चित करना चाहिए कि यह आपकी टीम के भीतर अच्छी तरह से प्रलेखित और अच्छी तरह से समझा गया है। व्यक्तिगत रूप से मैं फ्रेमवर्क दिशानिर्देशों के अनुसार रहना चाहूंगा।)
IDeepCloneable<T>अस्तित्व के लिए समझ में आता है, क्योंकि ... आप जानते हैं कि अगर आप अपना खुद का कार्यान्वयन करते हैं, तो टी क्या हैSomeClass : IDeepCloneable<SomeClass> { ... }
MyFunc(IDeepClonable data), तब यह सभी क्लोनों पर काम कर सकता था, न कि केवल एक विशिष्ट प्रकार पर। या अगर आपके पास क्लोन का संग्रह था। IEnumerable<IDeepClonable> lotsOfCloneablesतब आप एक ही समय में बहुत सारी वस्तुओं को क्लोन कर सकते हैं। यदि आपको उस तरह की चीज़ की आवश्यकता नहीं है, तो गैर-जेनेरिक को छोड़ दें।
C # में, कक्षा में कार्यक्षमता जोड़ने के लिए (डीप) कॉपी करने का पसंदीदा तरीका क्या है? क्या किसी को कॉपी कंस्ट्रक्टर को लागू करना चाहिए, या ICloneable से प्राप्त करना चाहिए और क्लोन () विधि को लागू करना चाहिए?
ICloneableजैसा कि दूसरों ने उल्लेख किया है कि यह समस्या है, यह निर्दिष्ट नहीं करता है कि यह एक गहरी या उथली प्रति है, जो इसे व्यावहारिक रूप से अनुपयोगी बना देती है और व्यवहार में, शायद ही कभी इसका उपयोग किया जाता है। यह भी लौटता है object, जो एक दर्द है, क्योंकि इसमें बहुत अधिक कास्टिंग की आवश्यकता होती है। (और यद्यपि आपने विशेष रूप से प्रश्न में कक्षाओं का उल्लेख किया है, ICloneableपर लागू करनाstruct बॉक्सिंग की आवश्यकता है।)
एक प्रतिलिपि अवरोधक भी ICloneable के साथ समस्याओं में से एक से ग्रस्त है। यह स्पष्ट नहीं है कि एक प्रतिलिपि निर्माता एक गहरी या उथली प्रतिलिपि बना रहा है या नहीं।
Account clonedAccount = new Account(currentAccount); // Deep or shallow?डीपक्लोन () विधि बनाना सबसे अच्छा होगा। इस तरह से मंशा पूरी तरह स्पष्ट है।
यह इस सवाल को उठाता है कि क्या यह एक स्थिर या उदाहरण विधि होना चाहिए।
Account clonedAccount = currentAccount.DeepClone(); // instance methodया
Account clonedAccount = Account.DeepClone(currentAccount); // static methodमैं कभी-कभी स्थैतिक संस्करण को थोड़ा पसंद करता हूं, सिर्फ इसलिए कि क्लोनिंग कुछ ऐसा लगता है जो ऑब्जेक्ट के बजाय किसी वस्तु को किया जा रहा है। या तो मामले में, ऐसे मुद्दों से निपटने के लिए जा रहे हैं जब क्लोनिंग ऑब्जेक्ट्स जो एक वंशानुगत पदानुक्रम का हिस्सा हैं, और उन मुद्दों के साथ कैसे अंत में डिज़ाइन को ड्राइव कर सकते हैं।
class CheckingAccount : Account
{
CheckAuthorizationScheme checkAuthorizationScheme;
public override Account DeepClone()
{
CheckingAccount clone = new CheckingAccount();
DeepCloneFields(clone);
return clone;
}
protected override void DeepCloneFields(Account clone)
{
base.DeepCloneFields(clone);
((CheckingAccount)clone).checkAuthorizationScheme = this.checkAuthorizationScheme.DeepClone();
}
}मैं मुख्य रूप से एक क्लोन विधि पर एक कॉपी कंस्ट्रक्टर का उपयोग करने की सलाह देता हूं क्योंकि एक क्लोन विधि आपको उन क्षेत्रों को बनाने से रोक readonlyसकती है जो हो सकते थे यदि आपने इसके बजाय एक कंस्ट्रक्टर का उपयोग किया था।
आप बहुरूपी क्लोनिंग की आवश्यकता होती है, तो आप एक जोड़ सकते हैं abstractया virtual Clone()विधि अपने आधार वर्ग के लिए है कि आप प्रति निर्माता के लिए एक कॉल के साथ लागू करते हैं।
यदि आपको एक से अधिक प्रकार की प्रतिलिपि की आवश्यकता होती है (उदाहरण: गहरी / उथली) तो आप इसे कॉपी कंस्ट्रक्टर में एक पैरामीटर के साथ निर्दिष्ट कर सकते हैं, हालांकि मेरे अनुभव में मुझे लगता है कि आमतौर पर गहरी और उथले नकल का मिश्रण होता है जो मुझे चाहिए।
उदाहरण के लिए:
public class BaseType {
readonly int mBaseField;
public BaseType(BaseType pSource) =>
mBaseField = pSource.mBaseField;
public virtual BaseType Clone() =>
new BaseType(this);
}
public class SubType : BaseType {
readonly int mSubField;
public SubType(SubType pSource)
: base(pSource) =>
mSubField = pSource.mSubField;
public override BaseType Clone() =>
new SubType(this);
}एक महान तर्क है कि आपको एक संरक्षित प्रतिलिपि निर्माता का उपयोग करके क्लोन () को लागू करना चाहिए
एक संरक्षित (गैर-सार्वजनिक) प्रतिलिपि निर्माता प्रदान करना और क्लोन विधि से इसे लागू करना बेहतर है। यह हमें एक वर्ग के एक उदाहरण के लिए एक वस्तु बनाने के कार्य को सौंपने की क्षमता देता है, इस प्रकार से सुरक्षा प्रदान करता है और साथ ही, संरक्षित प्रतिलिपि निर्माता का उपयोग करके वस्तुओं को सुरक्षित रूप से बनाता है।
तो यह "बनाम" प्रश्न नहीं है। आपको इसे करने के लिए कॉपी कंस्ट्रक्टर (ओं) और क्लोन इंटरफ़ेस दोनों की आवश्यकता हो सकती है।
(हालांकि अनुशंसित सार्वजनिक इंटरफ़ेस कंस्ट्रक्टर-आधारित के बजाय क्लोन () इंटरफ़ेस है।)
अन्य उत्तरों में स्पष्ट गहरे या उथले तर्क में न फंसे। वास्तविक दुनिया में यह लगभग हमेशा कुछ के बीच में होता है - और किसी भी तरह से, कॉलर की चिंता नहीं होनी चाहिए।
क्लोन () अनुबंध केवल "जब मैं पहले एक को बदलूंगा तो परिवर्तन नहीं होगा"। आपको कितना ग्राफ कॉपी करना है, या आप अनन्त पुनरावृत्ति से कैसे बचें, ऐसा होने से फोन करने वाले को चिंता नहीं होनी चाहिए।
लागू करने योग्य ICloneable की इस तथ्य के कारण अनुशंसित नहीं है कि यह निर्दिष्ट नहीं है कि क्या यह एक गहरी या उथली प्रतिलिपि है, इसलिए मैं निर्माणकर्ता के लिए जाऊंगा, या बस कुछ खुद को लागू करूंगा। शायद इसे DeepCopy () कहते हैं ताकि यह वास्तव में स्पष्ट हो सके!
IDeepCloneable<T>एक DeepClone()विधि के साथ एक इंटरफ़ेस को परिभाषित करता हूं ।
आप कॉपी निर्माता और अमूर्त कक्षाओं के साथ समस्याओं में भाग लेंगे। आप निम्नलिखित करना चाहते हैं कल्पना कीजिए:
abstract class A
{
public A()
{
}
public A(A ToCopy)
{
X = ToCopy.X;
}
public int X;
}
class B : A
{
public B()
{
}
public B(B ToCopy) : base(ToCopy)
{
Y = ToCopy.Y;
}
public int Y;
}
class C : A
{
public C()
{
}
public C(C ToCopy)
: base(ToCopy)
{
Z = ToCopy.Z;
}
public int Z;
}
class Program
{
static void Main(string[] args)
{
List<A> list = new List<A>();
B b = new B();
b.X = 1;
b.Y = 2;
list.Add(b);
C c = new C();
c.X = 3;
c.Z = 4;
list.Add(c);
List<A> cloneList = new List<A>();
//Won't work
//foreach (A a in list)
// cloneList.Add(new A(a)); //Not this time batman!
//Works, but is nasty for anything less contrived than this example.
foreach (A a in list)
{
if(a is B)
cloneList.Add(new B((B)a));
if (a is C)
cloneList.Add(new C((C)a));
}
}
}उपरोक्त करने के ठीक बाद, आप चाहते हैं कि आप या तो एक इंटरफ़ेस का उपयोग करें, या एक DeepCopy () / ICloneable.Clone () कार्यान्वयन के लिए व्यवस्थित हो जाएं।
ICloneable के साथ समस्या मंशा और निरंतरता दोनों है। यह कभी स्पष्ट नहीं है कि यह एक गहरी या उथली प्रति है। इस वजह से, यह शायद केवल एक ही तरीके से या किसी अन्य तरीके से उपयोग नहीं किया जाता है।
मुझे उस मामले पर कोई स्पष्ट होने के लिए एक सार्वजनिक प्रतिलिपि निर्माता नहीं मिला।
उस ने कहा, मैं आपके लिए काम करने वाली एक विधि प्रणाली शुरू करूंगा और इरादे से भरोसा रखूंगा (कुछ हद तक स्व दस्तावेज)
यदि आप जिस ऑब्जेक्ट को कॉपी करने की कोशिश कर रहे हैं, वह Serializable है तो आप इसे क्रमबद्ध करके और इसे deserializing करके क्लोन कर सकते हैं। फिर आपको प्रत्येक वर्ग के लिए एक कॉपी कंस्ट्रक्टर लिखने की आवश्यकता नहीं है।
मेरे पास अभी कोड नहीं है, लेकिन यह कुछ इस तरह है
public object DeepCopy(object source)
{
// Copy with Binary Serialization if the object supports it
// If not try copying with XML Serialization
// If not try copying with Data contract Serailizer, etc
}यह प्रश्न में कक्षा के कॉपी शब्दार्थों पर निर्भर है, जिसे आपको खुद को डेवलपर के रूप में परिभाषित करना चाहिए। चुना विधि आमतौर पर कक्षा के इच्छित उपयोग के मामलों पर आधारित होती है। शायद यह दोनों तरीकों को लागू करने का एक मतलब होगा। लेकिन दोनों समान नुकसान साझा करते हैं - यह बिल्कुल स्पष्ट नहीं है कि वे किस नकल पद्धति को लागू करते हैं। यह आपकी कक्षा के लिए प्रलेखन में स्पष्ट रूप से कहा जाना चाहिए।
मेरे लिए:
// myobj is some transparent proxy object
var state = new ObjectState(myobj.State);
// do something
myobject = GetInstance();
var newState = new ObjectState(myobject.State);
if (!newState.Equals(state))
throw new Exception();के बजाय:
// myobj is some transparent proxy object
var state = myobj.State.Clone();
// do something
myobject = GetInstance();
var newState = myobject.State.Clone();
if (!newState.Equals(state))
throw new Exception();आशय के स्पष्ट कथन के रूप में देखा गया।
मुझे लगता है कि क्लोन करने योग्य वस्तुओं के लिए एक मानक पैटर्न होना चाहिए, हालांकि मुझे यकीन नहीं है कि पैटर्न क्या होना चाहिए। क्लोनिंग के संबंध में, ऐसा लगता है कि तीन प्रकार की कक्षाएं हैं:
जहाँ तक मैं बता सकता हूँ, एक ही वर्ग के एक नए ऑब्जेक्ट को प्राप्त करने का एकमात्र तरीका (कम से कम .net 2.0) में मौजूदा ऑब्जेक्ट के रूप में एक सदस्य का उपयोग करना है। ऐसा लगता है कि एक अच्छा पैटर्न "नया" / "छाया" फ़ंक्शन क्लोन है जो हमेशा वर्तमान प्रकार को लौटाता है, जिसकी परिभाषा सदैव मेंबरवाइज़ क्लोन को कॉल करने के लिए होती है और फिर एक संरक्षित वर्चुअल सबरूटीन क्लीनअपक्लोन (ओरिऑबजेक्ट) को कॉल करना होता है। CleanupCode रूटीन को आधार के क्लोनिंग की जरूरतों को संभालने के लिए base.Cleanupcode को कॉल करना चाहिए और फिर अपना स्वयं का क्लीनअप जोड़ना चाहिए। यदि क्लोनिंग रूटीन को मूल ऑब्जेक्ट का उपयोग करना है, तो उसे टाइपकास्ट करना होगा, लेकिन अन्यथा केवल टाइपकास्टिंग मेम्बरवाइज़लोन कॉल पर होगी।
दुर्भाग्य से, वर्ग का निम्नतम स्तर जो टाइप (1) के बजाय टाइप (2) से ऊपर था, को यह मानने के लिए कोडित करना होगा कि इसके निचले प्रकारों को क्लोनिंग के लिए किसी स्पष्ट समर्थन की आवश्यकता नहीं होगी। मैं वास्तव में उसके आसपास कोई रास्ता नहीं देखता।
फिर भी, मुझे लगता है कि एक परिभाषित पैटर्न होने से बेहतर कुछ नहीं होगा।
संयोग से, अगर किसी को पता है कि किसी का आधार प्रकार iCloneable का समर्थन करता है, लेकिन उसके द्वारा उपयोग किए जाने वाले फ़ंक्शन का नाम नहीं जानता है, तो क्या किसी के आधार प्रकार के iCloneable.Clone फ़ंक्शन को संदर्भित करने का कोई तरीका है?
यदि आप सभी दिलचस्प उत्तरों और चर्चाओं के माध्यम से पढ़ते हैं, तो आप अभी भी अपने आप से पूछ सकते हैं कि आप गुणों की नकल कैसे करते हैं - उन सभी को स्पष्ट रूप से, या ऐसा करने का एक और अधिक सुरुचिपूर्ण तरीका है? यदि वह आपका शेष प्रश्न है, तो इस पर नज़र डालें (StackOverflow पर):
मैं एक सामान्य एक्सटेंशन विधि का उपयोग करके 3 पार्टी वर्गों के गुणों को "गहराई से" कैसे कर सकता हूं?
यह वर्णन करता है कि एक विस्तार विधि को कैसे लागू किया जाए CreateCopy()जो सभी गुणों सहित ऑब्जेक्ट की "गहरी" प्रतिलिपि बनाता है (मैन्युअल रूप से संपत्ति द्वारा संपत्ति की नकल करने के बिना)।