大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > C#技巧 > C# 类型基础——你可能忽略的技术细节

C# 类型基础——你可能忽略的技术细节(2)

关键词:技术细节类型基础  阅读(1145) 赞(11)

[摘要]本文是对C# 类型基础——你可能忽略的技术细节的讲解,对学习C#编程技术有所帮助,与大家分享。

  接下来,我们对 vPoint2 做点改动,看看会发生什么:

vPoint2.x = 2; 
result = vPoint1.Equals(vPoint2); // #5 返回true; #6 返回false; 
Console.WriteLine(result); 

3. 复杂值类型判等
  到现在,上面的这些方法,我们还没有走到的位置,就是 CanCompareBits 返回 false 以后的部分了。前面我们已经推测出了 CanCompareBits返回 false 的条件(值类型的成员包含引用类型),现在只要实现下就可以了。我们定义一个新的结构 Line,它代表直线上的线段,我们让它的一个成员为值类型 ValPoint,一个成员为引用类型 RefPoint,然后去作比较。

/* 结构类型 ValLine 的定义, 
public struct ValLine { 
public RefPoint rPoint; // 引用类型成员 
public ValPoint vPoint; // 值类型成员 
public Line(RefPoint rPoint, ValPoint vPoint) { 
this.rPoint = rPoint; 
this.vPoint = vPoint; 
} 
} 
*/ 

RefPoint rPoint = new RefPoint(1); 
ValPoint vPoint = new ValPoint(1); 

ValLine line1 = new ValLine (rPoint, vPoint); 
ValLine line2 = line1; 

result = line1.Equals(line2); // 此时已经存在一个装箱操作,调用ValueType.Equals() 
Console.WriteLine(result); // 返回True 

  这个例子的过程要复杂得多。在开始前,我们先思考一下,当我们写下 line1.Equals(line2)时,已经进行了一个装箱的操作。如果要进一步判等,显然不能去判断变量是否引用的堆上同一个对象,这样的话就没有意义了,因为总是会返回 false(装箱后堆上创建了两个对象)。那么应该如何判断呢?对 堆上对象 的成员(字段)进行一对一的比较,而成员又分为两种类型,一种是值类型,一种是引用类型。对于引用类型,去判断是否引用相等;对于值类型,如果是简单值类型,那么如同前一节讲述的去判断;如果是复杂类型,那么当然是递归调用了;最终直到要么是引用类型要么是简单值类型。

  NOTE:进行字段对字段的一对一比较,需要用到反射,如果不了解反射,可以参看 .Net 中的反射 系列文章。

  好了,我们现在看看实际的过程,是不是如同我们料想的那样,为了避免频繁的拖动滚动条查看 ValueType 的 Equals()方法,我拷贝了部分下来:

public override bool Equals (Object obj) 
{   if (CanCompareBits(this)) // #5     return FastEqualsCheck(thisObj, obj); // #6   // 利用反射获取类型的所有字段(或者叫类型成员)   FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance |   BindingFlags.Public | BindingFlags.NonPublic);   // 遍历字段进行比较   for (int i=0; i<thisFields.Length; i++)
  {     thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj,false);     thatResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, false);     if (thisResult == null)
    {       if (thatResult != null)         return false;     }     else if (!thisResult.Equals(thatResult))
    { // #7       return false;     }   }   return true; }

    1. 进入 ValueType 上的 Equals() 方法,#5 处返回了 false;
    2. 进入 for 循环,遍历字段。
    3. 第一个字段是 RefPoint 引用类型,#7 处,调用 System.Object 的 Equals()方法,到达#2,返回 true。
    4. 第二个字段是 ValPoint 值类型,#7 处,调用 System.ValType 的 Equals()方法,也就是当前方法本身。此处递归调用。
    5. 再次进入 ValueType 的 Equals() 方法,因为 ValPoint 为简单值类型,所以 #5 CanCompareBits 返回了 true,接着 #6 FastEqualsCheck 返回了 true。
    6. 里层 Equals()方法返回 true。
    7. 退出 for 循环。
    8. 外层 Equals() 方法返回 true。

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

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#中的对象判等。最后,我们讨论了浅度复制 和 深度复制,并比较了它们之间不同。

  记在这里,以后学习

«上一页12下一页»


相关评论