c# - गहरी क्लोनिंग वस्तुओं



.net clone (25)

मैं कुछ ऐसा करना चाहता हूं:

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = myObj.Clone();

और उसके बाद उस नई ऑब्जेक्ट में परिवर्तन करें जो मूल ऑब्जेक्ट में दिखाई नहीं दे रहा है।

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

मैं ऑब्जेक्ट को क्लोन या गहरी प्रतिलिपि कैसे बना सकता हूं ताकि क्लोन ऑब्जेक्ट को मूल ऑब्जेक्ट में दिखाई देने वाले किसी भी बदलाव के बिना संशोधित किया जा सके?


Answers

I think you can try this.

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = new MyObject(myObj); //DeepClone it

Code Generator

We have seen a lot of ideas from serialization over manual implementation to reflection and I want to propose a totally different approach using the CGbR Code Generator . The generate clone method is memory and CPU efficient and therefor 300x faster as the standard DataContractSerializer.

All you need is a partial class definition with ICloneable and the generator does the rest:

public partial class Root : ICloneable
{
    public Root(int number)
    {
        _number = number;
    }
    private int _number;

    public Partial[] Partials { get; set; }

    public IList<ulong> Numbers { get; set; }

    public object Clone()
    {
        return Clone(true);
    }

    private Root()
    {
    }
} 

public partial class Root
{
    public Root Clone(bool deep)
    {
        var copy = new Root();
        // All value types can be simply copied
        copy._number = _number; 
        if (deep)
        {
            // In a deep clone the references are cloned 
            var tempPartials = new Partial[Partials.Length];
            for (var i = 0; i < Partials.Length; i++)
            {
                var value = Partials[i];
                value = value.Clone(true);
                tempPartials[i] = value;
            }
            copy.Partials = tempPartials;
            var tempNumbers = new List<ulong>(Numbers.Count);
            for (var i = 0; i < Numbers.Count; i++)
            {
                var value = Numbers[i];
                tempNumbers.Add(value);
            }
            copy.Numbers = tempNumbers;
        }
        else
        {
            // In a shallow clone only references are copied
            copy.Partials = Partials; 
            copy.Numbers = Numbers; 
        }
        return copy;
    }
}

Note: Latest version has a more null checks, but I left them out for better understanding.


इन कदमों का अनुसरण करें:

  • Define an ISelf<T> with a read-only Self property that returns T , and ICloneable<out T> , which derives from ISelf<T> and includes a method T Clone() .
  • Then define a CloneBase type which implements a protected virtual generic VirtualClone casting MemberwiseClone to the passed-in type.
  • Each derived type should implement VirtualClone by calling the base clone method and then doing whatever needs to be done to properly clone those aspects of the derived type which the parent VirtualClone method hasn't yet handled.

For maximum inheritance versatility, classes exposing public cloning functionality should be sealed , but derive from a base class which is otherwise identical except for the lack of cloning. Rather than passing variables of the explicit clonable type, take a parameter of type ICloneable<theNonCloneableType> . This will allow a routine that expects a cloneable derivative of Foo to work with a cloneable derivative of DerivedFoo , but also allow the creation of non-cloneable derivatives of Foo .


सभी सार्वजनिक संपत्तियों की प्रतिलिपि बनाने के लिए सरल विस्तार विधि। किसी भी वस्तु के लिए काम करता है और कक्षा [Serializable] होने की आवश्यकता नहीं है। अन्य पहुंच स्तर के लिए बढ़ाया जा सकता है।

public static void CopyTo( this object S, object T )
{
    foreach( var pS in S.GetType().GetProperties() )
    {
        foreach( var pT in T.GetType().GetProperties() )
        {
            if( pT.Name != pS.Name ) continue;
            ( pT.GetSetMethod() ).Invoke( T, new object[] 
            { pS.GetGetMethod().Invoke( S, null ) } );
        }
    };
}

जबकि मानक अभ्यास ICloneable इंटरफेस को कार्यान्वित करना है ( here वर्णित here , इसलिए मैं पुनर्जन्म नहीं दूंगा), यहां कुछ समय पहले कोड प्रोजेक्ट पर मिले एक अच्छे गहरे क्लोन ऑब्जेक्ट कॉपर है और इसे हमारे सामान में शामिल किया गया है।

जैसा कि कहीं और बताया गया है, इसके लिए आपके ऑब्जेक्ट्स को क्रमबद्ध करने की आवश्यकता होती है।

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// Reference Article http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
/// Provides a method for performing a deep copy of an object.
/// Binary Serialization is used to perform the copy.
/// </summary>
public static class ObjectCopier
{
    /// <summary>
    /// Perform a deep Copy of the object.
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", "source");
        }

        // Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream)
        {
            formatter.Serialize(stream, source);
            stream.Seek(0, SeekOrigin.Begin);
            return (T)formatter.Deserialize(stream);
        }
    }
}

विचार यह है कि यह आपके ऑब्जेक्ट को क्रमबद्ध करता है और फिर इसे एक नई वस्तु में deserializes। लाभ यह है कि जब कोई ऑब्जेक्ट बहुत जटिल हो जाता है तो आपको सब कुछ क्लोन करने के बारे में चिंता करने की ज़रूरत नहीं है।

और विस्तार विधियों के उपयोग के साथ (मूल रूप से संदर्भित स्रोत से भी):

यदि आप सी # 3.0 के नए एक्सटेंशन विधियों का उपयोग करना पसंद करते हैं, तो निम्न हस्ताक्षर रखने के लिए विधि बदलें:

public static T Clone<T>(this T source)
{
   //...
}

अब विधि कॉल objectBeingCloned.Clone(); बन जाता है objectBeingCloned.Clone();

संपादित करें (10 जनवरी 2015) सोचा कि मैं इसका पुनरीक्षण करूँगा, उल्लेख करने के लिए मैंने हाल ही में (न्यूटनसॉफ्ट) जेसन का उपयोग करना शुरू कर दिया है, यह हल्का होना चाहिए , और [सीरियलज़ेबल] टैग के ऊपरी हिस्से से बचाता है। ( एनबी @atconway ने टिप्पणियों में बताया है कि निजी सदस्यों को JSON विधि का उपयोग करके क्लोन नहीं किया गया है)

/// <summary>
/// Perform a deep Copy of the object, using Json as a serialisation method. NOTE: Private members are not cloned using this method.
/// </summary>
/// <typeparam name="T">The type of object being copied.</typeparam>
/// <param name="source">The object instance to copy.</param>
/// <returns>The copied object.</returns>
public static T CloneJson<T>(this T source)
{            
    // Don't serialize a null object, simply return the default for that object
    if (Object.ReferenceEquals(source, null))
    {
        return default(T);
    }

    // initialize inner objects individually
    // for example in default constructor some list property initialized with some values,
    // but in 'source' these items are cleaned -
    // without ObjectCreationHandling.Replace default constructor values will be added to result
    var deserializeSettings = new JsonSerializerSettings {ObjectCreationHandling = ObjectCreationHandling.Replace};

    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), deserializeSettings);
}

As I couldn't find a cloner that meets all my requirements in different projects, I created a deep cloner that can be configured and adapted to different code structures instead of adapting my code to meet the cloners requirements. Its achieved by adding annotations to the code that shall be cloned or you just leave the code as it is to have the default behaviour. It uses reflection, type caches and is based on fasterflect . The cloning process is very fast for a huge amount of data and a high object hierarchy (compared to other reflection/serialization based algorithms).

https://github.com/kalisohn/CloneBehave

Also available as a nuget package: https://www.nuget.org/packages/Clone.Behave/1.0.0

For example: The following code will deepClone Address, but only perform a shallow copy of the _currentJob field.

public class Person 
{
  [DeepClone(DeepCloneBehavior.Shallow)]
  private Job _currentJob;      

  public string Name { get; set; }

  public Job CurrentJob 
  { 
    get{ return _currentJob; }
    set{ _currentJob = value; }
  }

  public Person Manager { get; set; }
}

public class Address 
{      
  public Person PersonLivingHere { get; set; }
}

Address adr = new Address();
adr.PersonLivingHere = new Person("John");
adr.PersonLivingHere.BestFriend = new Person("James");
adr.PersonLivingHere.CurrentJob = new Job("Programmer");

Address adrClone = adr.Clone();

//RESULT
adr.PersonLivingHere == adrClone.PersonLivingHere //false
adr.PersonLivingHere.Manager == adrClone.PersonLivingHere.Manager //false
adr.PersonLivingHere.CurrentJob == adrClone.PersonLivingHere.CurrentJob //true
adr.PersonLivingHere.CurrentJob.AnyProperty == adrClone.PersonLivingHere.CurrentJob.AnyProperty //true

मैंने CloneExtensions लाइब्रेरी प्रोजेक्ट बनाया है। यह अभिव्यक्ति वृक्ष रनटाइम कोड संकलन द्वारा उत्पन्न सरल असाइनमेंट ऑपरेशंस का उपयोग करके तेज़, गहरे क्लोन का प्रदर्शन करता है।

इसका इस्तेमाल कैसे करें?

फ़ील्ड और गुणों के बीच असाइनमेंट के स्वर के साथ अपने स्वयं के Clone या Copy विधियों को लिखने के बजाय प्रोग्राम अभिव्यक्ति वृक्ष का उपयोग करके स्वयं को अपने लिए करते हैं। एक्सटेंशन विधि के रूप में चिह्नित GetClone<T>() विधि आपको इसे अपने उदाहरण पर कॉल करने की अनुमति देती है:

var newInstance = source.GetClone();

newInstance का उपयोग करके आप source से newInstance प्रतिलिपि बनाई जानी चाहिए चुन सकते हैं:

var newInstance 
    = source.GetClone(CloningFlags.Properties | CloningFlags.CollectionItems);

क्या क्लोन किया जा सकता है?

  • आदिम (int, uint, बाइट, डबल, चार, आदि), ज्ञात अपरिवर्तनीय प्रकार (डेटटाइम, टाइमस्पैन, स्ट्रिंग) और प्रतिनिधियों (एक्शन, फनक इत्यादि सहित)
  • नल
  • टी [] सरणी
  • जेनेरिक वर्गों और structs सहित कस्टम वर्गों और structs।

निम्नलिखित वर्ग / संरचना सदस्यों को आंतरिक रूप से क्लोन किया जाता है:

  • जनता के मूल्य, न केवल पढ़े क्षेत्र
  • दोनों संपत्तियों के साथ सार्वजनिक गुणों के मूल्य प्राप्त करें और सेट करें
  • ICollection लागू करने के प्रकार के लिए संग्रह आइटम

यह कितना तेज़ है?

समाधान तेजी से प्रतिबिंब है, क्योंकि सदस्यों की जानकारी केवल एक बार इकट्ठी की जानी चाहिए, GetClone<T> पहले दिए गए प्रकार T लिए पहली बार उपयोग किया जाता है।

यह serialization- आधारित समाधान से भी तेज़ है जब आप एक ही प्रकार के T कुछ उदाहरणों को क्लोन करते हैं।

और अधिक...

documentation पर उत्पन्न अभिव्यक्तियों के बारे में और पढ़ें।

List<int> लिए नमूना अभिव्यक्ति डीबग सूची:

.Lambda #Lambda1<System.Func`4[System.Collections.Generic.List`1[System.Int32],CloneExtensions.CloningFlags,System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]],System.Collections.Generic.List`1[System.Int32]]>(
    System.Collections.Generic.List`1[System.Int32] $source,
    CloneExtensions.CloningFlags $flags,
    System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]] $initializers) {
    .Block(System.Collections.Generic.List`1[System.Int32] $target) {
        .If ($source == null) {
            .Return #Label1 { null }
        } .Else {
            .Default(System.Void)
        };
        .If (
            .Call $initializers.ContainsKey(.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32]))
        ) {
            $target = (System.Collections.Generic.List`1[System.Int32]).Call ($initializers.Item[.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32])]
            ).Invoke((System.Object)$source)
        } .Else {
            $target = .New System.Collections.Generic.List`1[System.Int32]()
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)
        ) {
            .Default(System.Void)
        } .Else {
            .Default(System.Void)
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)
        ) {
            .Block() {
                $target.Capacity = .Call CloneExtensions.CloneFactory.GetClone(
                    $source.Capacity,
                    $flags,
                    $initializers)
            }
        } .Else {
            .Default(System.Void)
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)
        ) {
            .Block(
                System.Collections.Generic.IEnumerator`1[System.Int32] $var1,
                System.Collections.Generic.ICollection`1[System.Int32] $var2) {
                $var1 = (System.Collections.Generic.IEnumerator`1[System.Int32]).Call $source.GetEnumerator();
                $var2 = (System.Collections.Generic.ICollection`1[System.Int32])$target;
                .Loop  {
                    .If (.Call $var1.MoveNext() != False) {
                        .Call $var2.Add(.Call CloneExtensions.CloneFactory.GetClone(
                                $var1.Current,
                                $flags,


                         $initializers))
                } .Else {
                    .Break #Label2 { }
                }
            }
            .LabelTarget #Label2:
        }
    } .Else {
        .Default(System.Void)
    };
    .Label
        $target
    .LabelTarget #Label1:
}

}

निम्नलिखित सी # कोड जैसा ही अर्थ है:

(source, flags, initializers) =>
{
    if(source == null)
        return null;

    if(initializers.ContainsKey(typeof(List<int>))
        target = (List<int>)initializers[typeof(List<int>)].Invoke((object)source);
    else
        target = new List<int>();

    if((flags & CloningFlags.Properties) == CloningFlags.Properties)
    {
        target.Capacity = target.Capacity.GetClone(flags, initializers);
    }

    if((flags & CloningFlags.CollectionItems) == CloningFlags.CollectionItems)
    {
        var targetCollection = (ICollection<int>)target;
        foreach(var item in (ICollection<int>)source)
        {
            targetCollection.Add(item.Clone(flags, initializers));
        }
    }

    return target;
}

क्या यह बिल्कुल नहीं है कि आप List<int> लिए अपनी Clone विधि कैसे लिखेंगे?


I like Copyconstructors like that:

    public AnyObject(AnyObject anyObject)
    {
        foreach (var property in typeof(AnyObject).GetProperties())
        {
            property.SetValue(this, property.GetValue(anyObject));
        }
        foreach (var field in typeof(AnyObject).GetFields())
        {
            field.SetValue(this, field.GetValue(anyObject));
        }
    }

If you have more things to copy add them


यदि आप पहले से ही तृतीय पक्ष एप्लिकेशन जैसे ValueInjecter या Automapper का उपयोग कर रहे हैं, तो आप ऐसा कुछ कर सकते हैं:

MyObject oldObj; // The existing object to clone

MyObject newObj = new MyObject();
newObj.InjectFrom(oldObj); // Using ValueInjecter syntax

इस विधि का उपयोग करने के लिए आपको अपनी वस्तुओं पर आईएसरियलज़ेबल या आईसीएलनेबल लागू करने की आवश्यकता नहीं है। यह एमवीसी / एमवीवीएम पैटर्न के साथ आम है, इस तरह के सरल उपकरण बनाए गए हैं।

CodePlex पर वैल्यूइंजेक्टर गहरे क्लोनिंग समाधान देखें।


ICloneable का उपयोग न करने का कारण यह नहीं है क्योंकि इसमें सामान्य इंटरफ़ेस नहीं है। इसका उपयोग करने का कारण यह नहीं है क्योंकि यह अस्पष्ट है । यह स्पष्ट नहीं करता है कि आपको उथले या गहरी प्रतिलिपि मिल रही है या नहीं; यह कार्यान्वयन करने के लिए है।

हां, MemberwiseClone एक उथली प्रतिलिपि बनाता है, लेकिन MemberwiseClone के विपरीत Clone नहीं है; यह शायद, DeepClone , जो अस्तित्व में नहीं है। जब आप अपने आईसीएलनेबल इंटरफ़ेस के माध्यम से किसी ऑब्जेक्ट का उपयोग करते हैं, तो आप यह नहीं जान सकते कि अंतर्निहित ऑब्जेक्ट किस प्रकार का क्लोनिंग करता है। (और एक्सएमएल टिप्पणियां इसे स्पष्ट नहीं कर पाएंगी, क्योंकि आपको ऑब्जेक्ट की क्लोन विधि के बजाय इंटरफ़ेस टिप्पणियां मिलेंगी।)

मैं आमतौर पर जो करता हूं वह एक Copy विधि बनाता है जो वही करता है जो मैं चाहता हूं।


यदि आप अज्ञात प्रकारों के लिए सही क्लोनिंग चाहते हैं तो आप fastclone पर एक नज़र fastclone

यह अभिव्यक्ति आधारित क्लोनिंग द्विआधारी क्रमिकरण से लगभग 10 गुना तेजी से काम कर रही है और पूर्ण ऑब्जेक्ट ग्राफ़ अखंडता को बनाए रखती है।

इसका अर्थ है: यदि आप अपने पदानुक्रम में एक ही ऑब्जेक्ट में कई बार संदर्भित करते हैं, तो क्लोन में संदर्भित एक उदाहरण भी होगा।

क्लोन किए जा रहे वस्तुओं को इंटरफेस, विशेषताओं या किसी भी अन्य संशोधन की आवश्यकता नहीं है।


संक्षिप्त जवाब यह है कि आप आईसीएलनेबल इंटरफ़ेस से प्राप्त होते हैं और फिर .clone फ़ंक्शन को लागू करते हैं। क्लोन को सदस्यवार प्रतिलिपि करना चाहिए और किसी भी सदस्य पर गहरी प्रतिलिपि करना चाहिए जिसके लिए इसकी आवश्यकता होती है, फिर परिणामी वस्तु को वापस कर दें। यह एक पुनरावर्ती ऑपरेशन है (यह आवश्यक है कि जिस वर्ग को आप क्लोन करना चाहते हैं उसके सभी सदस्य या तो मूल्य प्रकार हैं या आईसीएलनेबल लागू करते हैं और उनके सदस्य या तो मूल्य प्रकार हैं या आईसीएलनेबल लागू करते हैं, और इसी तरह)।

आईसीएलनेबल का उपयोग करके क्लोनिंग पर एक और विस्तृत स्पष्टीकरण के लिए, इस आलेख को देखें

लंबा जवाब "यह निर्भर करता है"। जैसा कि दूसरों द्वारा उल्लेख किया गया है, आईसीएलनेबल जेनेरिक द्वारा समर्थित नहीं है, परिपत्र वर्ग संदर्भों के लिए विशेष विचारों की आवश्यकता है, और वास्तव में कुछ लोगों द्वारा .NET Framework में "गलती" के रूप में देखा जाता है। क्रमबद्धता विधि आपके ऑब्जेक्ट्स पर निर्भर करता है, जो वे नहीं हो सकते हैं और जिन पर आपका कोई नियंत्रण नहीं हो सकता है। समुदाय में अभी भी बहुत बहस है जिस पर "सर्वश्रेष्ठ" अभ्यास है। हकीकत में, समाधानों में से कोई भी एक आकार का आकार नहीं है, सभी स्थितियों के लिए आईसीएलनेबल मूल रूप से व्याख्या की गई थी।

कुछ डेवलपर (इयान के लिए क्रेडिट) के लिए इस डेवलपर का कॉर्नर आलेख देखें।


यहां जुड़े विकल्पों में से कई के बारे में बहुत कुछ पढ़ने के बाद, और इस मुद्दे के लिए संभावित समाधान, मेरा मानना ​​है कि इयान पी के लिंक पर सभी विकल्पों को संक्षेप में सारांशित किया गया है (अन्य सभी विकल्प उन में भिन्नताएं हैं) और सर्वोत्तम समाधान प्रदान किया जाता है प्रश्न टिप्पणियों पर agiledeveloper.com/articles/cloning072002.htm

तो मैं यहां उन 2 संदर्भों के प्रासंगिक भागों की प्रतिलिपि बनाउंगा। इस तरह हम कर सकते हैं:

सी तेज में वस्तुओं को क्लोन करने के लिए सबसे अच्छी बात है!

सबसे पहले और सबसे महत्वपूर्ण, ये हमारे सभी विकल्प हैं:

अभिव्यक्ति पेड़ द्वारा फास्ट डीप कॉपी लेख में सीरियलाइजेशन, रिफ्लेक्शन एंड एक्सप्रेशन पेड़ द्वारा क्लोनिंग की प्रदर्शन तुलना भी है।

मैं आईसीएलनेबल क्यों चुनता हूं (यानी मैन्युअल रूप से)

agiledeveloper.com/articles/cloning072002.htm

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

यह उनके निष्कर्ष का मेरा थोड़ा संशोधित संस्करण है:

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

उम्मीद है कि यह कार्यान्वयन चीजों को स्पष्ट कर सकता है:

public class Person : ICloneable
{
    private final Brain brain; // brain is final since I do not want 
                // any transplant on it once created!
    private int age;
    public Person(Brain aBrain, int theAge)
    {
        brain = aBrain; 
        age = theAge;
    }
    protected Person(Person another)
    {
        Brain refBrain = null;
        try
        {
            refBrain = (Brain) another.brain.clone();
            // You can set the brain in the constructor
        }
        catch(CloneNotSupportedException e) {}
        brain = refBrain;
        age = another.age;
    }
    public String toString()
    {
        return "This is person with " + brain;
        // Not meant to sound rude as it reads!
    }
    public Object clone()
    {
        return new Person(this);
    }
    …
}

अब व्यक्ति से कक्षा प्राप्त करने पर विचार करें।

public class SkilledPerson extends Person
{
    private String theSkills;
    public SkilledPerson(Brain aBrain, int theAge, String skills)
    {
        super(aBrain, theAge);
        theSkills = skills;
    }
    protected SkilledPerson(SkilledPerson another)
    {
        super(another);
        theSkills = another.theSkills;
    }

    public Object clone()
    {
        return new SkilledPerson(this);
    }
    public String toString()
    {
        return "SkilledPerson: " + super.toString();
    }
}

आप निम्न कोड चलाने का प्रयास कर सकते हैं:

public class User
{
    public static void play(Person p)
    {
        Person another = (Person) p.clone();
        System.out.println(p);
        System.out.println(another);
    }
    public static void main(String[] args)
    {
        Person sam = new Person(new Brain(), 1);
        play(sam);
        SkilledPerson bob = new SkilledPerson(new SmarterBrain(), 1, "Writer");
        play(bob);
    }
}

उत्पादित उत्पादन होगा:

This is person with [email protected]
This is person with [email protected]
SkilledPerson: This is person with [email protected]
SkilledPerson: This is person with [email protected]

ध्यान दें, अगर हम वस्तुओं की संख्या की गिनती रखते हैं, तो यहां लागू क्लोन वस्तुओं की संख्या की सही गणना रखेगा।


Keep things simple and use AutoMapper as others mentioned, it's a simple little library to map one object to another... To copy an object to another with the same type, all you need is three lines of code:

MyType source = new MyType();
Mapper.CreateMap<MyType, MyType>();
MyType target = Mapper.Map<MyType, MyType>(source);

The target object is now a copy of the source object. Not simple enough? Create an extension method to use everywhere in your solution:

public static T Copy<T>(this T source)
{
    T copy = default(T);
    Mapper.CreateMap<T, T>();
    copy = Mapper.Map<T, T>(source);
    return copy;
}

By using the extension method, the three lines become one line:

MyType copy = source.Copy();

Q. Why would I choose this answer?

  • Choose this answer if you want the fastest speed .NET is capable of.
  • Ignore this answer if you want a really, really easy method of cloning.

In other words, go with another answer unless you have a performance bottleneck that needs fixing, and you can prove it with a profiler .

10x faster than other methods

The following method of performing a deep clone is:

  • 10x faster than anything that involves serialization/deserialization;
  • Pretty darn close to the theoretical maximum speed .NET is capable of.

And the method ...

For ultimate speed, you can use Nested MemberwiseClone to do a deep copy . Its almost the same speed as copying a value struct, and is much faster than (a) reflection or (b) serialization (as described in other answers on this page).

Note that if you use Nested MemberwiseClone for a deep copy , you have to manually implement a ShallowCopy for each nested level in the class, and a DeepCopy which calls all said ShallowCopy methods to create a complete clone. This is simple: only a few lines in total, see the demo code below.

Here is the output of the code showing the relative performance difference for 100,000 clones:

  • 1.08 seconds for Nested MemberwiseClone on nested structs
  • 4.77 seconds for Nested MemberwiseClone on nested classes
  • 39.93 seconds for Serialization/Deserialization

Using Nested MemberwiseClone on a class almost as fast as copying a struct, and copying a struct is pretty darn close to the theoretical maximum speed .NET is capable of.

Demo 1 of shallow and deep copy, using classes and MemberwiseClone:
  Create Bob
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Clone Bob >> BobsSon
  Adjust BobsSon details
    BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Elapsed time: 00:00:04.7795670,30000000

Demo 2 of shallow and deep copy, using structs and value copying:
  Create Bob
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Clone Bob >> BobsSon
  Adjust BobsSon details:
    BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Elapsed time: 00:00:01.0875454,30000000

Demo 3 of deep copy, using class and serialize/deserialize:
  Elapsed time: 00:00:39.9339425,30000000

To understand how to do a deep copy using MemberwiseCopy, here is the demo project that was used to generate the times above:

// Nested MemberwiseClone example. 
// Added to demo how to deep copy a reference class.
[Serializable] // Not required if using MemberwiseClone, only used for speed comparison using serialization.
public class Person
{
    public Person(int age, string description)
    {
        this.Age = age;
        this.Purchase.Description = description;
    }
    [Serializable] // Not required if using MemberwiseClone
    public class PurchaseType
    {
        public string Description;
        public PurchaseType ShallowCopy()
        {
            return (PurchaseType)this.MemberwiseClone();
        }
    }
    public PurchaseType Purchase = new PurchaseType();
    public int Age;
    // Add this if using nested MemberwiseClone.
    // This is a class, which is a reference type, so cloning is more difficult.
    public Person ShallowCopy()
    {
        return (Person)this.MemberwiseClone();
    }
    // Add this if using nested MemberwiseClone.
    // This is a class, which is a reference type, so cloning is more difficult.
    public Person DeepCopy()
    {
            // Clone the root ...
        Person other = (Person) this.MemberwiseClone();
            // ... then clone the nested class.
        other.Purchase = this.Purchase.ShallowCopy();
        return other;
    }
}
// Added to demo how to copy a value struct (this is easy - a deep copy happens by default)
public struct PersonStruct
{
    public PersonStruct(int age, string description)
    {
        this.Age = age;
        this.Purchase.Description = description;
    }
    public struct PurchaseType
    {
        public string Description;
    }
    public PurchaseType Purchase;
    public int Age;
    // This is a struct, which is a value type, so everything is a clone by default.
    public PersonStruct ShallowCopy()
    {
        return (PersonStruct)this;
    }
    // This is a struct, which is a value type, so everything is a clone by default.
    public PersonStruct DeepCopy()
    {
        return (PersonStruct)this;
    }
}
// Added only for a speed comparison.
public class MyDeepCopy
{
    public static T DeepCopy<T>(T obj)
    {
        object result = null;
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, obj);
            ms.Position = 0;
            result = (T)formatter.Deserialize(ms);
            ms.Close();
        }
        return (T)result;
    }
}

Then, call the demo from main:

void MyMain(string[] args)
{
    {
        Console.Write("Demo 1 of shallow and deep copy, using classes and MemberwiseCopy:\n");
        var Bob = new Person(30, "Lamborghini");
        Console.Write("  Create Bob\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Console.Write("  Clone Bob >> BobsSon\n");
        var BobsSon = Bob.DeepCopy();
        Console.Write("  Adjust BobsSon details\n");
        BobsSon.Age = 2;
        BobsSon.Purchase.Description = "Toy car";
        Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
        Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Debug.Assert(Bob.Age == 30);
        Debug.Assert(Bob.Purchase.Description == "Lamborghini");
        var sw = new Stopwatch();
        sw.Start();
        int total = 0;
        for (int i = 0; i < 100000; i++)
        {
            var n = Bob.DeepCopy();
            total += n.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
    }
    {               
        Console.Write("Demo 2 of shallow and deep copy, using structs:\n");
        var Bob = new PersonStruct(30, "Lamborghini");
        Console.Write("  Create Bob\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Console.Write("  Clone Bob >> BobsSon\n");
        var BobsSon = Bob.DeepCopy();
        Console.Write("  Adjust BobsSon details:\n");
        BobsSon.Age = 2;
        BobsSon.Purchase.Description = "Toy car";
        Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
        Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);                
        Debug.Assert(Bob.Age == 30);
        Debug.Assert(Bob.Purchase.Description == "Lamborghini");
        var sw = new Stopwatch();
        sw.Start();
        int total = 0;
        for (int i = 0; i < 100000; i++)
        {
            var n = Bob.DeepCopy();
            total += n.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
    }
    {
        Console.Write("Demo 3 of deep copy, using class and serialize/deserialize:\n");
        int total = 0;
        var sw = new Stopwatch();
        sw.Start();
        var Bob = new Person(30, "Lamborghini");
        for (int i = 0; i < 100000; i++)
        {
            var BobsSon = MyDeepCopy.DeepCopy<Person>(Bob);
            total += BobsSon.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n", sw.Elapsed, total);
    }
    Console.ReadKey();
}

Again, note that if you use Nested MemberwiseClone for a deep copy , you have to manually implement a ShallowCopy for each nested level in the class, and a DeepCopy which calls all said ShallowCopy methods to create a complete clone. This is simple: only a few lines in total, see the demo code above.

Value types vs. References Types

Note that when it comes to cloning an object, there is is a big difference between a " struct " and a " class ":

  • If you have a " struct ", it's a value type so you can just copy it, and the contents will be cloned (but it will only make a shallow clone unless you use the techniques in this post).
  • If you have a " class ", it's a reference type , so if you copy it, all you are doing is copying the pointer to it. To create a true clone, you have to be more creative, and use differences between value types and references types which creates another copy of the original object in memory.

See differences between value types and references types .

Checksums to aid in debugging

  • Cloning objects incorrectly can lead to very difficult-to-pin-down bugs. In production code, I tend to implement a checksum to double check that the object has been cloned properly, and hasn't been corrupted by another reference to it. This checksum can be switched off in Release mode.
  • I find this method quite useful: often, you only want to clone parts of the object, not the entire thing.

Really useful for decoupling many threads from many other threads

One excellent use case for this code is feeding clones of a nested class or struct into a queue, to implement the producer / consumer pattern.

  • We can have one (or more) threads modifying a class that they own, then pushing a complete copy of this class into a ConcurrentQueue .
  • We then have one (or more) threads pulling copies of these classes out and dealing with them.

This works extremely well in practice, and allows us to decouple many threads (the producers) from one or more threads (the consumers).

And this method is blindingly fast too: if we use nested structs, it's 35x faster than serializing/deserializing nested classes, and allows us to take advantage of all of the threads available on the machine.

अद्यतन करें

Apparently, ExpressMapper is as fast, if not faster, than hand coding such as above. I might have to see how they compare with a profiler.


This method solved the problem for me:

private static MyObj DeepCopy(MyObj source)
        {

            var DeserializeSettings = new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace };

            return JsonConvert.DeserializeObject<MyObj >(JsonConvert.SerializeObject(source), DeserializeSettings);

        }

Use it like this: MyObj a = DeepCopy(b);


मैं मुख्य रूप से primitives और सूचियों की बहुत सरल वस्तुओं के लिए एक क्लोनर चाहता था। यदि आपका ऑब्जेक्ट JSON serializable बॉक्स से बाहर है तो यह विधि चाल करेगी। इसके लिए क्लोन क्लास पर इंटरफेस का कोई संशोधन या कार्यान्वयन की आवश्यकता नहीं है, केवल JSON.NET जैसे JSON serializer।

public static T Clone<T>(T source)
{
    var serialized = JsonConvert.SerializeObject(source);
    return JsonConvert.DeserializeObject<T>(serialized);
}

मैं मैन्युअल रूप से गहरी प्रतिलिपि सूची <टी> के साथ होने वाली .NET कमी को दूर करने के लिए इसके साथ आया था।

मैं इसका उपयोग करता हूं:

static public IEnumerable<SpotPlacement> CloneList(List<SpotPlacement> spotPlacements)
{
    foreach (SpotPlacement sp in spotPlacements)
    {
        yield return (SpotPlacement)sp.Clone();
    }
}

और एक और जगह पर:

public object Clone()
{
    OrderItem newOrderItem = new OrderItem();
    ...
    newOrderItem._exactPlacements.AddRange(SpotPlacement.CloneList(_exactPlacements));
    ...
    return newOrderItem;
}

मैंने ऑनलाइनर के साथ आने की कोशिश की जो यह करता है, लेकिन यह संभव नहीं है, उपज के कारण अज्ञात विधि ब्लॉक के अंदर काम नहीं कर रहा है।

Better still, use generic List<T> cloner:

class Utility<T> where T : ICloneable
{
    static public IEnumerable<T> CloneList(List<T> tl)
    {
        foreach (T t in tl)
        {
            yield return (T)t.Clone();
        }
    }
}

If your Object Tree is Serializeable you could also use something like this

static public MyClass Clone(MyClass myClass)
{
    MyClass clone;
    XmlSerializer ser = new XmlSerializer(typeof(MyClass), _xmlAttributeOverrides);
    using (var ms = new MemoryStream())
    {
        ser.Serialize(ms, myClass);
        ms.Position = 0;
        clone = (MyClass)ser.Deserialize(ms);
    }
    return clone;
}

be informed that this Solution is pretty easy but it's not as performant as other solutions may be.

And be sure that if the Class grows, there will still be only those fields cloned, which also get serialized.


To clone your class object you can use the Object.MemberwiseClone method,

just add this function to your class :

public class yourClass
{
    // ...
    // ...

    public yourClass DeepCopy()
    {
        yourClass othercopy = (yourClass)this.MemberwiseClone();
        return othercopy;
    }
}

then to perform a deep independant copy, just call the DeepCopy method :

yourClass newLine = oldLine.DeepCopy();

उम्मीद है की यह मदद करेगा।


I've seen it implemented through reflection as well. Basically there was a method that would iterate through the members of an object and appropriately copy them to the new object. When it reached reference types or collections I think it did a recursive call on itself. Reflection is expensive, but it worked pretty well.


Here a solution fast and easy that worked for me without relaying on Serialization/Deserialization.

public class MyClass
{
    public virtual MyClass DeepClone()
    {
        var returnObj = (MyClass)MemberwiseClone();
        var type = returnObj.GetType();
        var fieldInfoArray = type.GetRuntimeFields().ToArray();

        foreach (var fieldInfo in fieldInfoArray)
        {
            object sourceFieldValue = fieldInfo.GetValue(this);
            if (!(sourceFieldValue is MyClass))
            {
                continue;
            }

            var sourceObj = (MyClass)sourceFieldValue;
            var clonedObj = sourceObj.DeepClone();
            fieldInfo.SetValue(returnObj, clonedObj);
        }
        return returnObj;
    }
}

EDIT : requires

    using System.Linq;
    using System.Reflection;

That's How I used it

public MyClass Clone(MyClass theObjectIneededToClone)
{
    MyClass clonedObj = theObjectIneededToClone.DeepClone();
}

I have created a version of the accepted answer that works with both '[Serializable]' and '[DataContract]'. It has been a while since I wrote it, but if I remember correctly [DataContract] needed a different serializer.

Requires System, System.IO, System.Runtime.Serialization, System.Runtime.Serialization.Formatters.Binary, System.Xml ;

public static class ObjectCopier
{

    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[Serializable]' or '[DataContract]'
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T Clone<T>(T source)
    {
        if (typeof(T).IsSerializable == true)
        {
            return CloneUsingSerializable<T>(source);
        }

        if (IsDataContract(typeof(T)) == true)
        {
            return CloneUsingDataContracts<T>(source);
        }

        throw new ArgumentException("The type must be Serializable or use DataContracts.", "source");
    }


    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[Serializable]'
    /// </summary>
    /// <remarks>
    /// Found on http://.com/questions/78536/cloning-objects-in-c-sharp
    /// Uses code found on CodeProject, which allows free use in third party apps
    /// - http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
    /// </remarks>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T CloneUsingSerializable<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", "source");
        }

        // Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream)
        {
            formatter.Serialize(stream, source);
            stream.Seek(0, SeekOrigin.Begin);
            return (T)formatter.Deserialize(stream);
        }
    }


    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[DataContract]'
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T CloneUsingDataContracts<T>(T source)
    {
        if (IsDataContract(typeof(T)) == false)
        {
            throw new ArgumentException("The type must be a data contract.", "source");
        }

        // ** Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        DataContractSerializer dcs = new DataContractSerializer(typeof(T));
        using(Stream stream = new MemoryStream())
        {
            using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
            {
                dcs.WriteObject(writer, source);
                writer.Flush();
                stream.Seek(0, SeekOrigin.Begin);
                using (XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
                {
                    return (T)dcs.ReadObject(reader);
                }
            }
        }
    }


    /// <summary>
    /// Helper function to check if a class is a [DataContract]
    /// </summary>
    /// <param name="type">The type of the object to check.</param>
    /// <returns>Boolean flag indicating if the class is a DataContract (true) or not (false) </returns>
    public static bool IsDataContract(Type type)
    {
        object[] attributes = type.GetCustomAttributes(typeof(DataContractAttribute), false);
        return attributes.Length == 1;
    }

} 

Ok, there are some obvious example with reflection in this post, BUT reflection is usually slow, until you start to cache it properly.

if you'll cache it properly, than it'll deep clone 1000000 object by 4,6s (measured by Watcher).

static readonly Dictionary<Type, PropertyInfo[]> ProperyList = new Dictionary<Type, PropertyInfo[]>();

than you take cached properties or add new to dictionary and use them simply

foreach (var prop in propList)
{
        var value = prop.GetValue(source, null);   
        prop.SetValue(copyInstance, value, null);
}

full code check in my post in another answer

https://.com/a/34365709/4711853


मेरे पास "सादे पुराने जावास्क्रिप्ट ऑब्जेक्ट" को क्लोन करना है या नहीं, इस पर निर्भर करते हुए मेरे पास दो अच्छे उत्तर हैं।

आइए यह भी मान लें कि आपका इरादा स्रोत ऑब्जेक्ट पर वापस प्रोटोटाइप संदर्भों के साथ एक पूर्ण क्लोन बनाना है। यदि आप एक पूर्ण क्लोन में रूचि नहीं रखते हैं, तो आप कुछ अन्य उत्तरों (क्रॉकफ़ोर्ड के पैटर्न) में प्रदान की गई ऑब्जेक्ट.क्लोन () रूटीन का उपयोग कर सकते हैं।

सादे पुराने जावास्क्रिप्ट ऑब्जेक्ट्स के लिए, आधुनिक रनटाइम्स में किसी ऑब्जेक्ट को क्लोन करने का एक प्रयास किया गया और सही अच्छा तरीका काफी सरल है:

var clone = JSON.parse(JSON.stringify(obj));

ध्यान दें कि स्रोत ऑब्जेक्ट एक शुद्ध JSON ऑब्जेक्ट होना चाहिए। यह कहना है, इसके सभी घोंसले वाले गुण स्केलर (जैसे बुलियन, स्ट्रिंग, सरणी, ऑब्जेक्ट इत्यादि) होना चाहिए। RegExp या दिनांक जैसे किसी भी फ़ंक्शन या विशेष ऑब्जेक्ट को क्लोन नहीं किया जाएगा।

क्या यह कुशल है? धत्त हां। हमने सभी प्रकार की क्लोनिंग विधियों का प्रयास किया है और यह सबसे अच्छा काम करता है। मुझे यकीन है कि कुछ निंजा एक तेज विधि को स्वीकार कर सकते हैं। लेकिन मुझे संदेह है कि हम मामूली लाभ के बारे में बात कर रहे हैं।

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

अब, गैर-सादे जावास्क्रिप्ट ऑब्जेक्ट्स के लिए, वास्तव में एक सरल जवाब नहीं है। वास्तव में, जावास्क्रिप्ट कार्यों और आंतरिक वस्तु स्थिति की गतिशील प्रकृति के कारण नहीं हो सकता है। कार्यों के साथ एक JSON संरचना को गहरा क्लोन करने के लिए आपको उन कार्यों और उनके आंतरिक संदर्भ को फिर से बनाना आवश्यक है। और जावास्क्रिप्ट में बस ऐसा करने का मानकीकृत तरीका नहीं है।

ऐसा करने का सही तरीका, एक बार फिर, एक सुविधाजनक विधि के माध्यम से है जिसे आप अपने कोड में घोषित करते हैं और पुन: उपयोग करते हैं। सुविधा विधि को अपनी वस्तुओं की कुछ समझ के साथ संपन्न किया जा सकता है ताकि आप नए ऑब्जेक्ट के भीतर ग्राफ को सही तरीके से पुनर्निर्मित कर सकें।

हम अपना खुद लिखा है, लेकिन मैंने देखा है कि सबसे अच्छा सामान्य दृष्टिकोण यहां शामिल है:

http://davidwalsh.name/javascript-clone

यह सही विचार है। लेखक (डेविड वॉल्श) ने सामान्यीकृत कार्यों के क्लोनिंग पर टिप्पणी की है। यह आपके द्वारा उपयोग किए जाने वाले मामले के आधार पर कुछ ऐसा करने का विकल्प चुन सकता है।

मुख्य विचार यह है कि आपको प्रति-प्रकार के आधार पर अपने कार्यों (या प्रोटोटाइप कक्षाओं, बोलने के लिए) के तत्कालता को विशेष रूप से संभालना होगा। यहां, उन्होंने RegExp और तिथि के लिए कुछ उदाहरण प्रदान किए हैं।

न केवल यह कोड संक्षिप्त है, बल्कि यह भी बहुत पठनीय है। विस्तार करना बहुत आसान है।

क्या यह कुशल है? धत्त हां। यह देखते हुए कि लक्ष्य एक वास्तविक गहरे प्रतिलिपि क्लोन का उत्पादन करना है, तो आपको स्रोत ऑब्जेक्ट ग्राफ़ के सदस्यों को चलना होगा। इस दृष्टिकोण के साथ, आप वास्तव में किस प्रकार के बच्चे के सदस्यों से इलाज कर सकते हैं और मैन्युअल रूप से कस्टम प्रकारों को कैसे प्रबंधित कर सकते हैं।

तो यह तूम गए वहाँ। दो दृष्टिकोण दोनों मेरे विचार में कुशल हैं।





c# .net clone