C#中的浅拷贝和深拷贝

#中有两种类型变量,一种是值类型变量,一种是引用类型变量。

对于前者,copy是属于全盘复制;而对于后者,一般的copy只是浅copy,只copy引用地址,相当于只传递一个引用指针一样。因此对于后者进行真正copy的时候,也是最费事的,具体的说,必须为其实现 ICloneable接口中提供的Clone方法,从而产生一个全新的对象。

浅拷贝(影子克隆):只复制对象的基本类型,对象类型,仍属于原来的引用. 
深拷贝(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的.

浅拷贝和深拷贝之间的区别:

浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中,而对象中的引用型字段则指复制它的一个引用到目标对象。如果改变目标对象中引用型字段的值他将反映在原始对象中,也就是说原始对象中对应的字段也会发生变化。

深拷贝与浅拷贝不同的是对于引用的处理,深拷贝将会在新对象中创建一个新的和原始对象中对应字段相同(内容相同)的字段,也就是说这个引用和原始对象的引用是不同的,我们在改变新对象中的这个字段的时候是不会影响到原始对象中对应字段的内容。

所以对于原型模式(prototype pattern)也有不同的两种处理方法:对象的浅拷贝和深拷贝

MemberwiseClone 方法创建一个浅表副本,方法是创建一个新对象,然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的,则对该字段执行逐位复制。如果字段是引用类型,则复制引用但不复制引用的对象;因此,原始对象及其复本引用同一对象。深拷贝,即实现ICloneable接口.ICloneable可用于深拷贝和浅拷贝。

.net提供了一个ICloneable接口,该接口下有一个Clone()方法,你可以实现它用来实现你自己的克隆方式,比如深克隆或是浅克隆,MemberwiseClone()是object类中的一个方法,用来实现类的浅克隆

using System.Collections.Generic;

 #region//深克隆 浅克隆 MemberwiseClone() clone()
    /// <summary>
    /// Abstract Class Animal
    /// </summary>
    public abstract class Animal
    {
        public int i;
        public double d;
        public byte b;
        public string[] s;
        public abstract Animal Clone();
    }

    /// <summary>
    /// SubClass Dog
    /// </summary>
    public class Dog : Animal
    {
        public Dog(int i, double d, byte b, string s1, string s2)
        {
            this.i = i;
            this.d = d;
            this.b = b;
            string[] ms = { s1, s2 };
            this.s = ms;
        }
        public override Animal Clone()
        {
            return (Animal)this.MemberwiseClone();
        }

    }
    #endregion
     protected void Page_Load(object sender, EventArgs e)
     {
            #region//深克隆 浅克隆 MemberwiseClone() clone()

            Animal a1 = new Dog(1, 2, 3, "A", "B");
            Response.Write("Animal a1 ‘s  members :"+a1.i+" "+a1.d+" "+ a1.b+ a1.s[0]+ a1.s[1]+"<br/>");

            Animal a2;
            a2 = a1.Clone();
            Response.Write("Animal a2 ‘s members : "+ a2.i+ a2.d+ a2.b+ a2.s[0]+ a2.s[1]+"<br/>");

            Response.Write("do a1.i = 9;a1.s[0] = C"+"<br/>");
            a1.i = 9;
            a1.s[0] = "C";
            Response.Write("Animal a1 ‘s members : "+a1.i+a1.d+ a1.b+ a1.s[0]+ a1.s[1]+"<br/>");
            Response.Write("Animal a2 ‘s members : "+ a2.i+ a2.d+ a2.b+ a2.s[0]+ a2.s[1]+"<br/>");

            Response.Write("do a2.i = 8;a2.s[1] =D" + "<br/>");
            a2.i = 8;
            a2.s[1] = "D";
            Response.Write("Animal a1 ‘s members : " + a1.i + a1.d + a1.b + a1.s[0] + a1.s[1] + "<br/>");
            Response.Write("Animal a2 ‘s members : " + a2.i + a2.d + a2.b + a2.s[0] + a2.s[1] + "<br/>");

            #endregion

        }

  

output

Animal a1 ‘s members :1 2 3ABAnimal a2 ‘s members : 123ABdo a1.i = 9;a1.s[0] = CAnimal a1 ‘s members : 923CBAnimal a2 ‘s members : 123CBdo a2.i = 8;a2.s[1] =DAnimal a1 ‘s members : 923CDAnimal a2 ‘s members : 823CD
 

如果用深克隆,虽然简单类可能只有值类型,但是指不定什么时候就有个引用类型。深克隆目前来说比较实在的方法是序列化加反序列化,当然也可以使用反射,或者一个对一个的赋值。一般是做一个方法比如叫DeepCopy().请看下面的例子:在Dog类中添加新方法 DeepClone(),同时Dog 类要实现[Serialize]

public Dog DeepClone()        {            BinaryFormatter bFormatter = new BinaryFormatter();            MemoryStream stream = new MemoryStream();            bFormatter.Serialize(stream, this);            stream.Seek(0, SeekOrigin.Begin);            return (Dog)bFormatter.Deserialize(stream);        }

Page_Load中添加:

 #region//深克隆 ICloneable接口下的 Clone()方法            Dog dog1 = new Dog(1, 2, 3, "A", "B");            Response.Write("Dog dog1 ‘s members :" + dog1.i + " " + dog1.d + " " + dog1.b + dog1.s[0] + dog1.s[1] + "<br/>");

            Dog dog2 = dog1.DeepClone();            Response.Write("Dog dog2 ‘s members : " + dog2.i + dog2.d + dog2.b + dog2.s[0] + dog2.s[1] + "<br/>");

            Response.Write("Change dog1.i = 9;dog1.s[0] = C" + "<br/>");            dog1.i = 9;            dog1.s[0] = "C";            Response.Write("Dog dog1 ‘s members :" + dog1.i + " " + dog1.d + " " + dog1.b + dog1.s[0] + dog1.s[1] + "<br/>");            Response.Write("Dog dog2 ‘s members : " + dog2.i + dog2.d + dog2.b + dog2.s[0] + dog2.s[1] + "<br/>");

            Response.Write("Change dog2.i = 8;dog2.s[1] = D" + "<br/>");            dog2.i = 8;            dog2.s[1] = "D";            Response.Write("Dog dog1 ‘s members :" + dog1.i + " " + dog1.d + " " + dog1.b + dog1.s[0] + dog1.s[1] + "<br/>");            Response.Write("Dog dog2 ‘s members : " + dog2.i + dog2.d + dog2.b + dog2.s[0] + dog2.s[1] + "<br/>");

            #endregion

output

Dog dog1 ‘s members :1 2 3ABDog dog2 ‘s members : 123ABChange dog1.i = 9;dog1.s[0] = CDog dog1 ‘s members :9 2 3CBDog dog2 ‘s members : 123ABChange dog2.i = 8;dog2.s[1] = DDog dog1 ‘s members :9 2 3CBDog dog2 ‘s members : 823AD
时间: 2024-10-05 06:50:42

C#中的浅拷贝和深拷贝的相关文章

Javascript中的浅拷贝和深拷贝

很多开发语言中都有浅拷贝和深拷贝的说法,这里简单区分一下它们在Javascript中的区别,以及jQuery中深拷贝的实现. 在谈浅拷贝和深拷贝之前,先要屡清楚Javascript中的按值访问和按引用访问这两个概念. 按值访问是针对基本类型(string.number.boolean.null.undefined).基本类型以值的形式被存放在栈内存中,我们通过变量操作的是栈内存中实际的值. 按引用访问时针对引用类型(Object.Array.Date.RegExp.Function).引用类型以

浅谈JS中的浅拷贝与深拷贝

前端工程师应该都比较熟悉浅拷贝和深拷贝的概念,在日常业务代码的过程中,特别是做数据处理的时候,经常行的会遇到,比如如何在不修改原对象的基础上,重新生成一个一模一样的对象,加以利用,又或是,如何巧妙地运用相关的内置API,来达成自己所需要的结果,比如数组相关的操作,splice和slice就是截然相反的处理,虽然同样是对数组进行截取操作,但是前者会影响原数组,后者则是返回一个新的数组对象,而对原来的数组并不会产生任何影响,这其中的差别,需要有一定的开发经验才能明白. 好了,废话也不多说,下面来简单

Objective-C中的浅拷贝和深拷贝详解

  浅拷贝 浅拷贝就是对内存地址的复制,让目标对象指针和源对象指向同一片内存空间.如: 1 2 char* str = (char*)malloc(100); char* str2 = str; 浅拷贝只是对对象的简单拷贝,让几个对象共用一片内存,当内存销毁的时候,指向这片内存的几个指针需要重新定义才可以使用,要不然会成为野指针. iOS 里面的浅拷贝: 在 iOS 里面, 使用retain 关键字进行引用计数,就是一种更加保险的浅拷贝.他既让几个指针共用同一片内存空间,又可以在release

Python中的浅拷贝与深拷贝

以下都是参考资料后,我自己的理解,如有错误希望大家不吝赐教. 大家有没有遇到这样一种情况,对象赋值后,对其中一个变量进行修改,另外一个变量的值也改变了.比如: person = ['name', ['saving', 100]] hubby = person wifey = person hubby[0] = 'joe' wifey[0] = 'jane' print hubby, wifey hubby[1][1] = 50 print hubby, wifey >>>['jane',

Objective-C中的浅拷贝和深拷贝

浅拷贝 浅拷贝就是对内存地址的复制,让目标对象指针和源对象指向同一片内存空间.如: char* str = (char*)malloc(100); char* str2 = str; 浅拷贝只是对对象的简单拷贝,让几个对象共用一片内存,当内存销毁的时候,指向这片内存的几个指针需要重新定义才可以使用,要不然会成为野指针. iOS 里面的浅拷贝: 在 iOS 里面, 使用retain 关键字进行引用计数,就是一种更加保险的浅拷贝.他既让几个指针共用同一片内存空间,又可以在release 由于计数的存

Objective-C中的浅拷贝和深拷贝差异和区别

浅拷贝  浅拷贝就是对内存地址的复制,让目标对象指针和源对象指向同一片内存空间.如: char* str = (char*)malloc(100); char* str2 = str; 浅拷贝只是对对象的简单拷贝,让几个对象共用一片内存,当内存销毁的时候,指向这片内存的几个指针需要重新定义才可以使用,要不然会成为野指针. iOS 里面的浅拷贝:  在 iOS 里面, 使用retain 关键字进行引用计数,就是一种更加保险的浅拷贝.他既让几个指针共用同一片内存空间,又可以在release 由于计数

python中的浅拷贝和深拷贝

1.浅拷贝 copy.copy() 浅拷贝是拷贝只拷贝最外一层(这里所说的拷贝是重新生成一个内存地址,也就是只有最外层的地址是重新生成) import copy li=[23,45,['wew',35,[33,00]]] li1=copy.copy(li) print(id(li),id(li1)) print(id(li[0]),id(li1[0])) print(id(li[2][1]),id(li1[2][1])) #输出:35540704 5872576 # 1625084720 162

Python 中的浅拷贝和深拷贝

1. 列表和字典,直接赋值,都是浅拷贝,即赋值双方指向同一地址,因为 Python 对可变对象按引用传递. >>> a = [1, 2, 3] >>> b = a >>> b [1, 2, 3] >>> a[0] = 'apple' >>> a ['apple', 2, 3] >>> b ['apple', 2, 3] >>> >>> >>> d

JS中的浅拷贝和深拷贝。

//浅拷贝 var o1 = { a: 10, b: 20, c: 30 }; var o2 = o1; o2.a = 100; console.log(o1); //深拷贝 var o1 = { a: 10, b: 20, c: 30 }; var o2 = { a: o1.a, b: o1.b, c: o1.c }; o2.a = 100; console.log(o1); //深拷贝 只适用于一维数组 var o1 = { a: 10, b: 20, c: 30 }; var o2 = {