您的位置:知识库 » .NET技术

C# 类型基础

作者: Jimmy Zhang  来源: 博客园  发布时间: 2009-02-27 13:40  阅读: 4143 次  推荐: 0   原文链接   [收藏]  
摘要:对C# 类型基础进行了详细地阐述|对象复制
[1] C# 类型基础
[2] C# 类型基础
[3] C# 类型基础
[4] C# 类型基础

对象复制

有的时候,创建一个对象可能会非常耗时,比如对象需要从远程数据库中获取数据来填充,又或者创建对象需要读取硬盘文件。此时,如果已经有了一个对象,再创建新对象时,可能会采用复制现有对象的方法,而不是重新建一个新的对象。本节就讨论如何进行对象的复制。

1.浅度复制

浅度复制 和 深度复制 是以如何复制对象的成员(member)来划分的。一个对象的成员有可能是值类型,有可能是引用类型。当我们对对象进行一个浅度复制的时候,对于值类型成员,会复制其本身(值类型变量本身包含了所有数据,复制时进行按位拷贝);对于引用类型成员(注意它会引用另一个对象),仅仅复制引用,而不创建其引用的对象。结果就是:新对象的引用成员和 复制对象的引用成员 指向了同一个对象。

继续我们上面的例子,如果我们想要进行复制的对象(RefLine)是这样定义的,(为了避免look up,我在这里把代码再贴过来):

// 将要进行 浅度复制 的对象,注意为 引用类型
public class RefLine {
    public RefPoint rPoint;
    public ValPoint vPoint;
    public Line(RefPoint rPoint,ValPoint vPoint){
       this.rPoint = rPoint;
       this.vPoint = vPoint;
    }
}
// 定义一个引用类型成员
public class RefPoint {
    public int x;
    public RefPoint(int x) {
       this.x = x;
    }
}
// 定义一个值类型成员
public struct ValPoint {
    public int x;
    public ValPoint(int x) {
       this.x = x;
    }
}

我们先创建一个想要复制的对象:

RefPoint rPoint = new RefPoint(1);
ValPoint vPoint = new ValPoint(1);
RefLine line = new RefLine(rPoint, vPoint);

它所产生的实际效果是(堆栈上仅考虑line部分):

那么当我们对它复制时,就会像这样(newLine是指向新拷贝的对象的指针,在代码中体现为一个引用类型的变量):

按照这个定义,再回忆上面我们讲到的内容,可以推出这样一个结论:当复制一个结构类型成员的时候,直接创建一个新的结构类型变量,然后对它赋值,就相当于进行了一个浅度复制,也可以认为结构类型隐式地实现了浅度复制。如果我们将上面的RefLine定义为一个结构(Struct),结构类型叫ValLine,而不是一个类,那么对它进行浅度复制就可以这样:

ValLine newLine = line;

实际的效果图是这样:

现在你已经已经搞清楚了什么是浅度复制,知道了如何对结构浅度复制。那么如何对一个引用类型实现浅度复制呢?在.Net Framework中,有一个ICloneable接口,我们可以实现这个接口来进行浅度复制(也可以是深度复制,这里有争议,国外一些人认为ICloneable应该被标识为过时(Obsolete)的,并且提供IShallowCloneable和IDeepCloneble来替代)。这个接口只要求实现一个方法Clone(),它返回当前对象的副本。我们并不需要自己实现这个方法(当然完全可以),在System.Object基类中,有一个保护的MemeberwiseClone()方法,它便用于进行浅度复制。所以,对于引用类型,如果想要实现浅度复制时,只需要调用这个方法就可以了:

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

现在我们来做一个测试:

class Program {
    static void Main(string[] args) {

       RefPoint rPoint = new RefPoint(1);
       ValPoint vPoint = new ValPoint(1);
       RefLine line = new RefLine(rPoint, vPoint);

       RefLine newLine = (RefLine)line.Clone();
       Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.rPoint.x, line.vPoint.x);
       Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.rPoint.x, newLine.vPoint.x);

       line.rPoint.x = 10;      // 修改原先的line的 引用类型成员 rPoint
       line.vPoint.x = 10;      // 修改原先的line的 值类型  成员 vPoint
       Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.rPoint.x, line.vPoint.x);
       Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.rPoint.x, newLine.vPoint.x);

    }
}

输出为:

Original: line.rPoint.x = 1, line.vPoint.x = 1
Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1
Original: line.rPoint.x = 10, line.vPoint.x = 10
Cloned: newLine.rPoint.x = 10, newLine.vPoint.x = 1

可见,复制后的对象和原先对象成了连体婴,它们的引用成员字段依然引用堆上的同一个对象。

2.深度复制

其实到现在你可能已经想到什么时深度复制了,深度复制就是将引用成员指向的对象也进行复制。实际的过程是创建新的引用成员指向的对象,然后复制对象包含的数据。

深度复制可能会变得非常复杂,因为引用成员指向的对象可能包含另一个引用类型成员,最简单的例子就是一个线性链表。

如果一个对象的成员包含了对于线性链表结构的一个引用,浅度复制 只复制了对头结点的引用,深度复制 则会复制链表本身,并复制每个结点上的数据。

考虑我们之前的例子,如果我们期望进行一个深度复制,我们的Clone()方法应该如何实现呢?

public object Clone(){       // 深度复制
    RefPoint rPoint = new RefPoint();       // 对于引用类型,创建新对象
    rPoint.x = this.rPoint.x;           // 复制当前引用类型成员的值 到 新对象
    ValPoint vPoint = this.vPoint;          // 值类型,直接赋值
    RefLine newLine = new RefLine(rPoint, vPoint);
    return newLine;
}

可以看到,如果每个对象都要这样去进行深度复制的话就太麻烦了,我们可以利用串行化/反串行化来对对象进行深度复制:先把对象串行化(Serialize)到内存中,然后再进行反串行化,通过这种方式来进行对象的深度复制:

public object Clone() {
    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, this);
    ms.Position = 0;

    return (bf.Deserialize(ms)); ;
}

我们来做一个测试:

class Program {
    static void Main(string[] args) {
       RefPoint rPoint = new RefPoint(1);
       ValPoint vPoint = new ValPoint(2);

       RefLine line = new RefLine(rPoint, vPoint);
       RefLine newLine = (RefLine)line.Clone();
                 
       Console.WriteLine("Original line.rPoint.x = {0}", line.rPoint.x);
       Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.rPoint.x);

       line.rPoint.x = 10;   // 改变原对象 引用成员 的值
       Console.WriteLine("Original line.rPoint.x = {0}", line.rPoint.x);
       Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.rPoint.x);
    }
}
输出为:
Original line.rPoint.x = 1
Cloned newLine.rPoint.x = 1
Original line.rPoint.x = 10
Cloned newLine.rPoint.x = 1

可见,两个对象的引用成员已经分离,改变原对象的引用对象的值,并不影响复制后的对象。

这里需要注意:如果想将对象进行序列化,那么对象本身,及其所有的自定义成员(类、结构),都必须使用Serializable特性进行标记。所以,如果想让上面的代码运行,我们之前定义的类都需要进行这样的标记:

[Serializable()]
public class RefPoint { /*略*/}

NOTE:关于特性(Attribute),可以参考 .Net 中的反射(反射特性) 一文。

总结

本文简单地对C#中的类型作了一个回顾。

我们首先讨论了C#中的两种类型--值类型和引用类型,随后简要回顾了装箱/拆箱 操作。接着,详细讨论了C#中的对象判等。最后,我们讨论了浅度复制和 深度复制,并比较了它们之间不同。

希望这篇文章能给你带来帮助!

0
0
 
标签:clr

.NET技术热门文章

    .NET技术最新文章

      最新新闻

        热门新闻