C# में शैलो कॉपी और डीप कॉपी में क्या अंतर है?

शैलो कॉपी (Shallow Copy)

ऑब्जेक्ट की शैलो कॉपी "मुख्य" ऑब्जेक्ट को कॉपी करती है, लेकिन इनर ऑब्जेक्ट्स को कॉपी नहीं करती।

• इनर ऑब्जेक्ट्स मूल ऑब्जेक्ट और उसकी कॉपी के बीच शेयर किए जाते हैं
• दोनों ऑब्जेक्ट्स स्वतंत्र नहीं होते
• यदि एक ऑब्जेक्ट में संशोधन किया जाए, तो परिवर्तन दूसरे में भी प्रतिबिंबित होता है

डीप कॉपी (Deep Copy)

डीप कॉपी ऑब्जेक्ट की पूरी तरह स्वतंत्र कॉपी होती है। यदि हम अपने ऑब्जेक्ट को कॉपी करते हैं, तो हम पूरी ऑब्जेक्ट संरचना को कॉपी करते हैं।

• संपूर्ण ऑब्जेक्ट ग्राफ़ की नई कॉपी बनती है
• दोनों ऑब्जेक्ट्स पूरी तरह स्वतंत्र होते हैं
• एक ऑब्जेक्ट में संशोधन दूसरे को प्रभावित नहीं करता

उदाहरण: अंतर दिखाता हुआ कोड

class Program {
    static void Main(string[] args) {
        // === शैलो कॉपी ===
        Console.WriteLine("=== Shallow Copy ===");
        ShallowCopy obj = new ShallowCopy();
        obj.a = 10;
        
        ShallowCopy obj1 = new ShallowCopy();
        obj1 = obj;  // रेफरेंस असाइनमेंट - शैलो कॉपी!
        
        Console.WriteLine("{0} {1}", obj1.a, obj.a);  // 10, 10
        obj1.a = 5;
        Console.WriteLine("{0} {1}", obj1.a, obj.a);  // 5, 5 - दोनों बदल गए!
        
        // === डीप कॉपी ===
        Console.WriteLine("\n=== Deep Copy ===");
        DeepCopy d = new DeepCopy();
        d.a = 10;
        
        DeepCopy d1 = new DeepCopy();
        d1.a = d.a;  // वैल्यू कॉपी - डीप कॉपी (प्रिमिटिव के लिए)
        
        Console.WriteLine("{0} {1}", d1.a, d.a);  // 10, 10
        d1.a = 5;
        Console.WriteLine("{0} {1}", d1.a, d.a);  // 5, 10 - केवल d1 बदला!
        
        Console.ReadLine();
    }
}

class ShallowCopy {
    public int a = 10;
}

class DeepCopy {
    public int a = 10;
}

आउटपुट

=== Shallow Copy ===
10 10
5 5

=== Deep Copy ===
10 10
5 10

रेफरेंस टाइप्स के साथ वास्तविक अंतर

उपरोक्त उदाहरण प्रिमिटिव (int) का उपयोग करता है जहाँ असाइनमेंट स्वाभाविक रूप से वैल्यू कॉपी करता है। रेफरेंस टाइप्स के साथ अंतर स्पष्ट होता है:

public class Address {
    public string City { get; set; }
}

public class Person {
    public string Name { get; set; }
    public Address Address { get; set; }  // रेफरेंस टाइप
}

// शैलो कॉपी
Person person1 = new Person { Name = "John", Address = new Address { City = "Delhi" } };
Person person2 = person1;  // शैलो कॉपी - समान Address रेफरेंस!

person2.Address.City = "Mumbai";
Console.WriteLine(person1.Address.City);  // "Mumbai" - मूल भी बदल गया!

// डीप कॉपी - मैन्युअल
Person person3 = new Person { 
    Name = person1.Name, 
    Address = new Address { City = person1.Address.City }  // नया Address ऑब्जेक्ट
};

person3.Address.City = "Bangalore";
Console.WriteLine(person1.Address.City);  // "Mumbai" - मूल अपरिवर्तित

डीप कॉपी करने के तरीके

1. मैन्युअल कॉपी (कंस्ट्रक्टर/फैक्टरी)

public class Person {
    public Person DeepCopy() {
        return new Person {
            Name = this.Name,
            Address = new Address { City = this.Address.City }
        };
    }
}

2. ICloneable इंटरफ़ेस

public class Person : ICloneable {
    public object Clone() {
        return this.DeepCopy();
    }
}

3. सीरियलाइज़ेशन (बाइनरी/JSON)

// JSON सीरियलाइज़ेशन (Newtonsoft.Json या System.Text.Json)
string json = JsonSerializer.Serialize(person1);
Person person2 = JsonSerializer.Deserialize<Person>(json);

// बाइनरी सीरियलाइज़ेशन (केवल [Serializable] क्लासेज़ के लिए)
using (var ms = new MemoryStream()) {
    var formatter = new BinaryFormatter();
    formatter.Serialize(ms, person1);
    ms.Position = 0;
    Person person2 = (Person)formatter.Deserialize(ms);
}

4. MemberwiseClone (शैलो कॉपी के लिए बिल्ट-इन)

protected Person ShallowCopy() {
    return (Person)this.MemberwiseClone();
}

तुलना तालिका

कब क्या उपयोग करें?

• शैलो कॉपी: केवल प्रिमिटिव फील्ड्स, इम्यूटेबल ऑब्जेक्ट्स, परफॉरमेंस-क्रिटिकल कोड
• डीप कॉपी: म्यूटेबल रेफरेंस टाइप फील्ड्स, जब स्वतंत्र संशोधन आवश्यक हो