浅析Object基类提供的Virtual Object.Equals, Static Object.Equals and Reference.Equals等三个方法

  当我们去查看object.cs源代码文件的时候,会发现object基类提供了三种判断相等性的方法。弄清楚每种方法存在的原因,也就是具体解决了什么问题,对我们理解.net判断对象相等性的逻辑很有帮助,下面让我们分别来看看吧!

1、Virtual Object.Equals()方法

  实际上.net中提供了几种比较相等性(equality)的方法,但是最基础的方法就数object类中定义的virtual Object.Equals()了。下面让我们以一个customer类来看看该方法的实际运作。

static void Main(string[] args)
        {
            Customer C1 = new Customer();
            C1.FirstName = "Si";
            C1.LastName = "Li";
            Customer C2 = new Customer();
            C2.FirstName = "San";
            C2.LastName = "Zhang";
            Console.WriteLine(C1.Equals(C2));
            Console.Read();
        }
        public class Customer
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        } 

  上图代码的比较结果为False,这正是我们所期望的结果。因为两个Customer实例的字段值包含不同的字符序列。细心一点的童鞋也许会发现,我们并没有Customer类中定义Equals方法,它是怎么进行比较的呢?这里的Equals方法实际调用的就是Object基类的Virtual Object.Equals()方法。

  另外,有些童鞋在看到上面代码中使用Equals方法进行比较时,也许会想为何不直接使用==运算符进行比较,这样不是更简洁明了么?是的,使用==运算符确实使得代码更加具有可读性,但是,需要注意的是:它并不是.Net FrameWork框架的一部分。若想理解.net中是如何优雅的处理equality问题的,还是需要从equals方法开始学习。

  接下来,让我们稍微改变下代码,增加一个新的Customer实例C3,该实例和C1具有相同的字段值,看看会出现什么样的结果。

 static void Main(string[] args)
        {
            Customer C1 = new Customer();
            C1.FirstName = "Si";
            C1.LastName = "Li";
            Customer C2 = new Customer();
            C2.FirstName = "San";
            C2.LastName = "Zhang";
            Customer C3 = new Customer();
            C2.FirstName = "Si";
            C2.LastName = "Li";
            Console.WriteLine(C1.Equals(C3));
            Console.Read();
        }

  上图代码中C1和C3的比较结果为false。至于原因,想必大多数童鞋都已经知道了,那就是Object基类的Equals虚方法比较引用相等性,即两个变量是否指向同一个实例对象。很明显,C1和C3指向两个不同的实例对象,因此,Equals比较的结果就是False。

  如果我们需要比较两个Customer实例的值,字段值相等就说他们是相等的,那么我们就需要自己去实现Equals方法,来覆盖Object提供的虚Equals方法。关于实现过程中需要注意的地方本文暂不讨论。

2、String的相等性判断

  FCL库中有几个引用类型,因为在开发中经常被开发人员拿来做相等性的比较,所以微软对他们提供了相等性的实现,该实现override了Object的Virtual Equals方法,可以比较值相等而不是引用相等。其中,最常用到的一个就是String类型。下面我们以一小段代码来演示String的Equals方法。

static void Main(String[] args)
        {
            string s1 = "Hello World";
            string s2 = string.Copy(s1);  

            Console.WriteLine(s1.Equals((object)s2));
        }  

  上面代码中,我们定义了两个sting类型的引用变量,s1和s2。两者具有相同的字符序列值,但却是两个不同的引用。

  另外,细心的童鞋也许会注意到,我们将Equals方法的参数强转到object类型,在实际开发中,明显不会这样做。这里之所以这样做,就是因为String类型定义了多个Equals方法,如下图所示。而在这里,我们需要确保String类型的对Object的Equals方法的override实现被调用。

  比较的结果正合我们的预期,String的override Equals方法比较两个字符串的内容是否包含相同的字符序列,若是则返回true,否则,返回false。

  微软在FCL中定义的引用类型并不多,对于这些引用类型,一般均提供了对Object的Equals方法的override实现,用来比较值。除了Sting类型之外,还有Delegate和Tuple。

3、Value Types的相等性判断

  这次,我们以customer类相似的例子举例,但将使用customer struct类型。

static void Main(string[] args)
        {
            Customer C1 = new Customer();
            C1.FirstName = "Si";
            C1.LastName = "Li";
            Customer C2 = new Customer();
            C2.FirstName = "San";
            C2.LastName = "Zhang";
            Customer C3 = new Customer();
            C3.FirstName = "Si";
            C3.LastName = "Li";
            Console.WriteLine(C1.Equals(C2));
            Console.WriteLine(C1.Equals(C3));
            Console.Read();
        }
        public struct Customer
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

  运行结果为:第一个Equals为False,第二个为True。我们知道,object基类的虚Equals方法比较引用而非值,但本例中struct是value type,若比较引用就毫无意义可言。仅就比较的结果来看,似乎在比较C1和C3的值。但在Customer struct类型的定义中并没有任何代码override了object的虚Equals方法。这是怎么做到的呢?

  答案就是:struct 类型均继承自System.ValueType(继承自 System.Object),System.ValueType类型override了object的虚Equals方法,该override方法的实现会遍历value type中的每一个字段,然后在每个字段上调用各自的Equals方法。若每个字段比较的结果均相等就返回true,否则,返回false。

3.1 Value Types相等性判断的开销

  使用微软为value type提供的默认相等性判断方法是有代价的。该override的Equals方法在内部是通过反射实现的。这是不可避免的,因为 System.ValueType是一个基类型,它不知道继承的子类型的信息。因此,只有在运行时通过反射发现自定义类型的字段信息,这就造成了性能损失。

3.2 Value Types相等性判断的可选方案

  为了快速的比较自定义value type,一般而言,我们需要自己override objece基类的Equals方法。实际上,微软已经为FCL中的大多数内置值类型提供了相应的实现。

4、Object的Static Equals方法

  使用object基类的虚Equals进行相等性判断存在一个问题,就是调用Equals方法的实例对象不能为null,否则,将抛出Null Reference Exception。这是因为不能在null上调用实例方法。

  Object的static Equals方法就是为了解决这个问题而出现的。当待比较的两个实例对象中有一个是null时,该静态Equals方法将返回false。

  相信不少童鞋会好奇,若两个实例对象均为null,会发生什么呢?答案就是返回true。在.net的世界中,null总是等于null。

  如果我们去查看Object类的static Equals方法的实现,就会发现其实它的代码逻辑十分简单明了,下面让我们一起看看吧。

public static bool Equals(object objA, object objB)
        {
            if (objA == objB)
            {
                return true;
            }
            if (objA == null || objB == null)
            {
                return false;
            }
            return objA.Equals(objB);
        }

  从上面代码中,可以看到static Equal方法首先判断两个参数是否指向同一个实例对象(包括两者都为null),若是,则直接返回true。接着判断两者之一是否为null,若是则返回false。最后,若控制流到达最后一条语句,则调用object的虚Equals方法。这意味着,static Equals方法除了进行null检查之外,它总是和virtual Equals方法返回相同的结果。此外,需要注意的是,若我们override了Object的virtual Equals方法,那么,static Equals方法中对virtual Equals的调用将自动调用override的Equals方法。

5、Object的ReferenceEquals方法

  ReferenceEquals方法存在的目的是为了比较两个引用变量是否指向同一个实例对象。不少童鞋对此持怀疑态度,virtual Equals和static Equals方法就是在比较引用相等性,有必要单独造一个方法来比较引用相等性么?

   不错,上面两个方法确实检测引用相等性,但它们不保证一定会检测,因为virtual Equals方法能被overridden来比较值而非引用。

   因此,对于没有override Equals方法的类型来说,ReferenceEquals方法将和Equals方法产生相同的结果。我们可以拿前面的String类型例子来说明这一点。

static void Main(String[] args)
        {
            string s1 = "Hello World";
            string s2 = string.Copy(s1);  

            Console.WriteLine(s1.Equals((object)s2));
            Console.WriteLine(ReferenceEquals(s1,s2));
        }  

   从上面的结果可以看出,第一个Equals方法返回true,而ReferenceEquals方法返回false。

  我们知道,在C#中static方法不能被override,这就保证了ReferenceEquals方法的行为会始终保持一致,这是很有意义的,因为我们总是会需要一个稳定不变的方法来判断引用相等。

  

原文地址:https://www.cnblogs.com/lian--ying/p/9500894.html

时间: 2024-12-09 08:09:10

浅析Object基类提供的Virtual Object.Equals, Static Object.Equals and Reference.Equals等三个方法的相关文章

System.Object 基类

System.Object 基类 System.Object在.Net中是所有类型的基类,任何类型都直接或间接地继承自System.Object.没有指定基类的类型都默认继承于System.Object. 基类特性 正由于所有的类型都继承于System.Object.因此,所有的类型都具有下面这些特性: GetType()方法,获取对象的类型. Equals.ReferenceEquals和==,判断对象是否相等. ToString()方法,获取对象的字符串信息,默认返回对象带命名空间的全名.

07——为多态基类声明为virtual析构函数

当基类确定被继承的时候,析构函数声明为virtual是必须的 当返回的派生类的指针或引用的时候,调用析构函数容易发生内存泄漏 当基类作为抽象类使用,声明pure virtual析构函数 析构函数的顺序————派生类的析构函数先被调用(先析构基类成员) 构造函数的顺序————派生类的构造函数先被调用(先构造基类成员) 07--为多态基类声明为virtual析构函数

Object基类

知识点 值类型. 值类型是在栈中分配内存,在声明时初始化才能使用,不能为null. 值类型超出作用范围系统自动释放内存. 主要由两类组成:结构,枚举(enum),结构分为以下几类: 整型(Sbyte.Byte.Char.Short.Ushort.Int.Uint.Long.Ulong) 浮点型(Float.Double) decimal bool 用户定义的结构(struct) 引用类型. 引用类型在堆中分配内存,初始化时默认为null. 引用类型是通过垃圾回收机制进行回收. 包括类.接口.委托

.NET Framework中Object基类有哪些方法?

ToString(),虚方法,任何子类可重写自定义 GetType(),非虚,返回类型名 Equals(),虚方法,默认情况下判定两个引用是否指向同一实例.(ReferenceEquals()功能相同,静态方法Equals()面对值类型判定值是否相等,面对引用类型,判定是否指向同一实例.) GetHashCode() 返回对象的哈希值.在重写equals方法时需要重写GetHashCode以保持统一.可以通过new Random().GetHashCode()得到真随机数. Memberwise

关于python中的 object基类

参考:[1] stackoverflow: what is the difference between old style and new style classes in Python? [2] The Inside Story on New-style Classes

c++ 基类已经存在virtual修饰的同名成员函数,派生类加不加无所谓,都是virtual的

1 struct A 2 { 3 virtual void f() {tcout << _T("A::f()\n");} 4 }; 5 6 struct B : public A 7 { 8 void f() {tcout << _T("B::f()\n");} 9 }; 10 11 struct C : public B 12 { 13 void f() {tcout << _T("C::f()\n");}

Java Object根类

Object类是Java中其他所有类的祖先,没有Object类Java面向对象无从谈起.作为其他所有类的基类,Object具有哪些属性和行为,是Java语言设计背后的思维体现. Object类位于java.lang包中,java.lang包包含着Java最基础和核心的类,在编译时会自动导入.Object类没有定义属性,一共有13个方法,具体的类定义结构如下图: 1.类构造器public Object(); 大部分情况下,Java中通过形如 new A(args..)形式创建一个属于该类型的对象.

Effective C++学习笔记 条款07:为多态基类声明virtual析构函数

一.C++明确指出:当derived class对象经由一个base class指针被删除,而该base class带着一个non-virtual析构函数,其结果未定义——实际执行时通常发生的是对象的derived成分没有被销毁!(注:使用基类引用派生类的方式使用多态,由于引用只是对原对象的一个引用或者叫做别名,其并没有分配内存,对其引用对象内存的销毁,将由原对象自己负责,所以使用引用的时候,如果析构函数不为virtual,那么也不会发生derived成员没有销毁的情况) 例如: class b

effective c++ 条款07(为多态基类声明virtual析构函数)整理

一.虚函数表原理 陈皓的一篇blog讲的很透彻:http://blog.csdn.net/haoel/article/details/1948051/ 虚函数表可以分为:单一继承无虚函数覆盖.单一继承有虚函数覆盖.多重继承无虚函数覆盖和多重继承和有虚函数覆盖. 注意与虚拟继承区分开来 二.多态实现原理 多态则是通过继承.虚函数(virtual).指针来实现. class A { public: virtual void func() const { coust << "A::func