C#中的深复制和浅复制（在C#中克隆对象）

最新推荐文章于 2024-02-07 17:36:01 发布

鹧鸪菜

最新推荐文章于 2024-02-07 17:36:01 发布

阅读量937

点赞数

分类专栏： C#/VS.Net/Mono

C#/VS.Net/Mono 专栏收录该内容

164 篇文章 2 订阅

订阅专栏

http://hi.baidu.com/a807423180/item/3642bc4aef7697cec1a59259

C#中的深复制和浅复制（在C#中克隆对象）

最近开发中对泛型数据进行排序，但是还需要用到原始数据，所以就复制了该对象到另一个对象，忘记了引用类型是传地址的，所以出了bug，转贴一篇文章，记录一下自己的错误。

C# 支持两种类型：“值类型”和“引用类型”。
值类型（Value Type)（如 char、int 和 float）、枚举类型和结构类型。
引用类型(Reference Type) 包括类 (Class) 类型、接口类型、委托类型和数组类型。

如何来划分它们？
以它们在计算机内存中如何分配来划分

值类型与引用类型的区别?
1,值类型的变量直接包含其数据，
2,引用类型的变量则存储对象引用。
对于引用类型，两个变量可能引用同一个对象，因此对一个变量的操作可能影响另一个变量所引用的对象。对于值类型，每个变量都有自己的数据副本，对一个变量的操作不可能影响另一个变量。

值类型隐式继承自System.ValueType 所以不能显示让一个结构继承一个类，C#不支持多继承

堆栈(stack)是一种先进先出的数据结构，在内存中，变量会被分配在堆栈上来进行操作。
堆(heap)是用于为类型实例(对象)分配空间的内存区域，在堆上创建一个对象，
会将对象的地址传给堆栈上的变量(反过来叫变量指向此对象，或者变量引用此对象)。

关于对象克隆的所设计到知识点

浅拷贝：是指将对象中的所有字段逐字复杂到一个新对象
对值类型字段只是简单的拷贝一个副本到目标对象，改变目标对象中值类型字段的值不会反映到原始对象中，因为拷贝的是副本
对引用型字段则是指拷贝他的一个引用到目标对象。改变目标对象中引用类型字段的值它将反映到原始对象中，因为拷贝的是指向堆是上的一个地址

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

浅复制：实现浅复制需要使用Object类的MemberwiseClone方法用于创建一个浅表副本
深复制：须实现 ICloneable接口中的Clone方法，且需要需要克隆的对象加上[Serializable]特性

class DrawBase:System.Object , ICloneable
{
public string name = "jmj";
public DrawBase()
{
}

public object Clone()
{
return this as object; //引用同一个对象
return this.MemberwiseClone(); //浅复制
return new DrawBase() as object;//深复制
}
}
class Program
{

static void Main(string[] args)
{
DrawBase rect = new DrawBase();
Console.WriteLine(rect.name);
DrawBase line = rect.Clone() as DrawBase;
line.name = "a9fs3";
Console.WriteLine(rect.name);
DrawBase ploy = line.Clone() as DrawBase;
ploy.name = "lj";
Console.WriteLine(rect.name);

Console.WriteLine(object.ReferenceEquals(line, ploy));
Console.ReadLine();
}
}
运行结果：
return this as object; //引用同一个对象
输出：jmj
a9fs3
lj
True

return this.MemberwiseClone(); //浅复制
return new DrawBase() as object;//深复制
输出均为: jmj
jmj
jmj
False
解释：
return this as object 方法总是引用同一个对象，因此相应的堆内存上的值会改变！
后两种方法都是对对象的复制，区别在于复制的类别不同：深复制会复制整个填充的对象，包括该对象中其他引用类型和值类型的值；而浅复制只复制了一个对象中所有引用，它没有值的复制，通过引用它们的其他对象的引用来共享它们。

http://www.cnblogs.com/zjypp/archive/2011/07/14/2319269.html

如何来划分它们？
以它们在计算机内存中如何分配来划分

值类型隐式继承自System.ValueType 所以不能显示让一个结构继承一个类，C#不支持多继承

关于对象克隆的所设计到知识点

先看看浅克隆的实例

class Pet
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Cat cat = new Cat();

        public Pet() { }
        public Pet(string name, int age)
        {
            this.Name = name;
            this.Age = age;
            cat.CatName = name;
        }

        public Object Clone()
        {
            return this.MemberwiseClone();
        }
    }
    public class Cat
    {
        public string CatName { get; set; }
    }

//测试代码

           Pet p = new Pet("p",1);
            Pet b = p.Clone() as Pet;

            Console.WriteLine(p.Name+"_"+p.cat.CatName);//输出p_p
            p.Name = "pp";
            p.cat.CatName = "xx";
            Console.WriteLine(b.Name + "_" + b.cat.CatName);//输出：p_xx

            Console.WriteLine( p.Equals(b));//输出false，克隆出来是新的对象

定义了Pet类和Cat类，其中Pet类用到了Cat类

Pet类中的name字段是值类型，Pet中的cat是引用类型。

根据浅克隆的原则，对值类型的修改是相互不影响的，

但是引用类型是相互类型的，克隆出来的对象和原来的对象保持对一个引用的对象的链接，修改了Pet中cat的名称属性，在克隆出来的类b中是有影响的

二，深克隆，深拷贝

还是用原来的代码，修改其中clone的方法

[Serializable]
    class Pet : ICloneable
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Cat cat = new Cat();

        public Pet() { }
        public Pet(string name, int age)
        {
            this.Name = name;
            this.Age = age;
            cat.CatName = name;
        }

        public Object Clone()
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            bf.Serialize(ms, this);
            ms.Seek(0, SeekOrigin.Begin);
            return bf.Deserialize(ms);

        }
    }
     [Serializable]
    public class Cat
    {
        public string CatName { get; set; }
    }

测试输出结果

Pet p = new Pet("p",1);
            Pet b = p.Clone() as Pet;

            Console.WriteLine(p.Name+"_"+p.cat.CatName);//输出p_p
            p.Name = "pp";
            p.cat.CatName = "xx";
            Console.WriteLine(b.Name + "_" + b.cat.CatName);//输出p_p，p类的修改没有影响b

            Console.WriteLine( p.Equals(b));//false

深克隆p类和b类，对cat有不同的引用的，所以p修改cat不会影响b类

深克隆上面使用的是序列化的方式

将它序列化并立刻反序列化为一个新对象。该种方式必须克隆的对象必须是可序列化的。所以需要在Pet类和Cat上声明是可序列化,方法是在类上面加上[Serializable]

另外一个方式是手工方式，在Clone方法人工来维护各个引用对象，并赋值。这个当然比较繁琐，尤其类中有比较多对象的时候，但是有时候可能对象不能序列化就要用到这个方式了

本文使用Blog_Backup未注册版本导出，请到soft.pt42.com注册。