CLR学习笔记--对象比较方法梳理

最新推荐文章于 2023-09-15 20:11:01 发布
最新推荐文章于 2023-09-15 20:11:01 发布
阅读量892 收藏
点赞数
分类专栏： CLR 文章标签： C# Equals
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/july_lee/article/details/11663537
版权

一、引言

对于对象的比较，C#提供了很多种比较方法，以及==和！=等运算来进行对象的同一性和相等性的比较，但我们在实际的编写代码中，可能会混淆各个方法的用法，在此废话不多说，我们一起来看些这几种方法的具体用法及含义。

二、Object. Equals (object obj)

这个方法是Object提供的虚方法，对于该方法，我们先区别引用类型和值类型的用法

对于引用类型，如果没有重写Equals，则默认比较对象的同一性，即比较引用地址，C#中大多数引用类型都重写了该方法，例如String类型比较的字符串是否相等

对于值类型，默认比较的是对象的相等性（即struct中所有字段的相等性）因为struct类型继承于System.ValueType而ValueType类中重写了Object中的Equals方法，代码具体实现可通过Reflector工具查看

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demo
{
    public struct MyStruct
    {
        public int item;
        public MyStruct(int i)
        {
            item = i;
        }
    }
    public class MyClass
    {
        private int item;
        public int Item
        {
            get { return item; }
            set { item = value; }
        }
        public MyClass(int i)
        {
            item = i;
        }
        public MyClass() { }
    }
    public class MyNewClass
    {
        private int item1;
        public int Item1
        {
            get { return item1; }
            set { item1 = value; }
        }
        private float item2;
        public float Item2
        {
            get { return item2; }
            set { item2 = value; }
        }
        public MyNewClass(int i, float j)
        {
            item1 = i;
            item2 = j;
        }
        public MyNewClass() { }
        //重写了Object.Equals
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            MyNewClass o = obj as MyNewClass;
            if (o == null) return false;
            return item1 == o.item1 && item2 == o.item2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //没有重写Object.Equals的引用类型
            MyClass mc1 = new MyClass(1);
            MyClass mc2 = new MyClass(1);
            MyClass mc3 = mc2;
            //值类型
            MyStruct stc1 = new MyStruct(1);
            MyStruct stc2 = new MyStruct(1);
            MyStruct stc3 = new MyStruct(2);
            //重写了Object.Equals的引用类型
            MyNewClass nc1 = new MyNewClass(1, 1.0f);
            MyNewClass nc2 = new MyNewClass(1, 1.0f);
            MyNewClass nc3 = new MyNewClass(2, 1.0f);
            //比较没有重写Object.Equals的引用类型实例对象
            Console.WriteLine(mc1.Equals(mc2));//比较引用地址 返回False
            Console.WriteLine(mc2.Equals(mc3));//比较引用地址 返回True
            //比较值类型的实例对象
            Console.WriteLine(stc1.Equals(stc2));//ValueType重写了Equals方法，比较的是结构体中的所有字段 返回True
            Console.WriteLine(stc2.Equals(stc3));//比较结构体中的所有字段 返回False
            //比较重写了Object.Eqauls的引用类型实例对象
            //比较实例对象中所有字段的相等性
            Console.WriteLine(nc1.Equals(nc2));//比较对象中实例字段相等性 返回Ture
            Console.WriteLine(nc2.Equals(nc3));//返回False
            Console.Read();
        }
    }
}
输出结果：


三、Object. Equals (object objA,object objB)

这个方法是Object对象提供的静态方法

这个方法比较的过程是这样的：objA如果和objB引用相同实例或者两者同时为null时返回True，如果不满足前者情况，则返回objA.Equals(objB)的结果

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demo
{
    public struct MyStruct
    {
        public int item;
        public MyStruct(int i)
        {
            item = i;
        }
    }
    public class MyClass
    {
        private int item;
        public int Item
        {
            get { return item; }
            set { item = value; }
        }
        public MyClass(int i)
        {
            item = i;
        }
        public MyClass() { }
    }
    public class MyNewClass
    {
        private int item1;
        public int Item1
        {
            get { return item1; }
            set { item1 = value; }
        }
        private float item2;
        public float Item2
        {
            get { return item2; }
            set { item2 = value; }
        }
        public MyNewClass(int i, float j)
        {
            item1 = i;
            item2 = j;
        }
        public MyNewClass() { }
        //重写了Object.Equals
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            MyNewClass o = obj as MyNewClass;
            if (o == null) return false;
            return item1 == o.item1 && item2 == o.item2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {

            MyClass mc1 = new MyClass(1);
            MyClass mc2 = new MyClass(1);
            MyClass mc3 = mc2;

            MyStruct stc1 = new MyStruct(1);
            MyStruct stc2 = new MyStruct(1);
            object stc3 = stc2;

            MyNewClass nc1 = new MyNewClass(1, 1.0f);
            MyNewClass nc2 = new MyNewClass(1, 1.0f);

            Console.WriteLine(object.Equals(null, null));//两者都为null 返回True
            Console.WriteLine(object.Equals(mc1, mc2));//返回的是mc1.Equals(mc2)的结果 返回False
            Console.WriteLine(object.Equals(mc2, mc3));//返回的是mc2.Equals(mc3)的结果 返回True

            //对于值类型，调用object.Equals静态方法时，会发生装箱操作
            //实际比较时，返回是MyStruct结构体中重写的Equals方法
            Console.WriteLine(object.Equals(stc1, stc2));//返回的是stc1.Equals(stc2)的结果 返回True
            //stc2发生两次装箱过程
            //1、object stc3=stc2 stc2在GC堆上装箱，并将一个地址返回给stc3
            //2、调用object.Equals(stc2,stc3)，stc2在GC又装箱一次，并将引用地址返回给第一个形参
            //两次装箱后，引用地址不同，实际比较时，返回的是MyStruct结构体中重写的Equals方法
            Console.WriteLine(object.Equals(stc2, stc3));//返回的是stc2.Equals(stc3)的结果，返回True

            Console.WriteLine(object.Equals(nc1, nc2));//返回的是nc1.Equals(nc2)的结果，返回True
            Console.Read();
        }
    }
}
输出结果：


四、Object. ReferenceEquals (object objA,object objB)

这个方法是Object对象提供的静态方法，该方法只比较objA和objB是否引用同一个对象实例，且该方法对值类型的比较永远返回False.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demo
{
    public struct MyStruct
    {
        public int item;
        public MyStruct(int i)
        {
            item = i;
        }
    }
    public class MyClass
    {
        private int item;
        public int Item
        {
            get { return item; }
            set { item = value; }
        }
        public MyClass(int i)
        {
            item = i;
        }
        public MyClass() { }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass m1 = new MyClass(1);
            MyClass m2 = new MyClass(1);
            MyClass m3 = m2;

            MyStruct s1 = new MyStruct(1);
            MyStruct s2 = new MyStruct(1);
            MyStruct s3 = s2;

            Console.WriteLine(object.ReferenceEquals(m1, m2));//比较引用地址 返回False
            Console.WriteLine(object.ReferenceEquals(m2, m3));//比较引用地址 返回True

            Console.WriteLine(object.ReferenceEquals(s1, s2));//s1与s2装箱后引用的地址不一致，比较引用值永远返回False
            Console.WriteLine(object.ReferenceEquals(s3, s2));//返回False

            Console.Read();
        }
    }
}

输出结果：



五、==和！= 运算符重载

“==”和“!=”对于引用类型和值类型比较方式主要有以下不同

1、  对于引用类型，如果没有重载”==”和“!=”操作符的情况下，默认比较的是引用地址，很多.NET引用类型都重载了”==“和”！=“操作符，例如String类的”==“比较的是两个字符串是否相同

2、  对于.NET的基元值类型（short、Int16、Int32、Boolean等）在调用“==“和”!=”,CLR会实现内置的比较方式

3、  对于没有同重载“==”和“！=”的值类型，调用“==”和“！=”会引起编译器错误

通常我们设计一个类时，如果重写了Object.Equals(object o)时，一般也会重载“==“和”!=“操作符，并且重载“==”操作符调用重写的Equals方法.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demo
{
    public struct MyStruct
    {
        public int item;
        public MyStruct(int i)
        {
            item = i;
        }
    }
    public struct MyNewStruct
    {
        public int item;
        public MyNewStruct(int i)
        {
            item = i;
        }
        public static bool operator ==(MyNewStruct m1, MyNewStruct m2)
        {
            return m1.Equals(m2);
        }
        public static bool operator !=(MyNewStruct m1, MyNewStruct m2)
        {
            return !m1.Equals(m2);
        }
    }
    public class MyClass
    {
        private int item;
        public int Item
        {
            get { return item; }
            set { item = value; }
        }
        public MyClass(int i)
        {
            item = i;
        }
        public MyClass() { }
    }
    public class MyNewClass
    {
        private int item;
        public int Item
        {
            get { return item; }
            set { item = value; }
        }
        public MyNewClass(int i)
        {
            item = i;
        }
        //重写了Object.Equals方法
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            if (this.GetType() != obj.GetType()) return false;
            MyNewClass m = obj as MyNewClass;
            return item.Equals(m.item);
        }
        //重载“==”操作符编译器要求同时必须要重载"!="
        public static bool operator ==(MyNewClass m1, MyNewClass m2)
        {
            return m1.Equals(m2);
        }
        public static bool operator !=(MyNewClass m1, MyNewClass m2)
        {
            return !m1.Equals(m2);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //基元值类型
            Int32 i = 3;
            Int32 j = 3;
            //自定义值类型（没能重载”==”和“！=”）
            MyStruct s1 = new MyStruct(1);
            MyStruct s2 = new MyStruct(1);
            //自定义值类型（重载了“==”和“！=”）
            MyNewStruct ns1 = new MyNewStruct(1);
            MyNewStruct ns2 = new MyNewStruct(1);
            //没有重载“==”和“！=”的引用类型
            MyClass c1 = new MyClass(1);
            MyClass c2 = new MyClass(1);
            MyClass c3 = c2;
            //重载了“==”和”！=“的引用类型
            MyNewClass nc1 = new MyNewClass(1);
            MyNewClass nc2 = new MyNewClass(1);

            Console.WriteLine(i == j);//基元值类型==比较 返回True

            //自定义值类型（汉有重载==）调用==比较时，编译器提示错误
            //Console.WriteLine(s1 == s2);

            Console.WriteLine(ns1 == ns2);//自定义结构体重载了==操作符，返回 True

            Console.WriteLine(c1 == c2);//没有重载==操作符的引用类型比较，比较引用地址 返回 False
            Console.WriteLine(c2 == c3);//没有重载==操作符的引用类型比较，比较引用地址 返回 True

            Console.WriteLine(nc1 == nc2);//重载了==操作符的引用类型比较，调用nc1.Equals(nc2) 返回True
            Console.Read();
        }
    }
}
输出结果：


此外我们要注意上面一段在代码在编译时，编译器提示有几个警告：


一个类型在重写了Equals方法或者重载了运算符“==、！=“之后，之所以编译器警告要同时定义GetHashCode，是因为在System.Collections.Hashtable类型、System.Collections.Genceric.Dictionary类型以及其他的一些集合中，要求两个对象为了相等，必须具胡相同的哈稀码，所以如果重写了Equals,编译器会提醒你，还应重写GetHashCode,确保相等性算法和对象哈稀算法一致，对于哈稀算法，在此篇不做讨论


July_Lee
关注
专栏目录
【DDD】学习笔记-设计概念的统一语言
xqdd的专栏
02-28 994
设计概念的统一语言
CLR 全面透彻解析--大型对象堆揭秘
牛牛的小窝
06-28 1001
CLR 垃圾回收器 (GC) 将对象分为大型、小型两类。如果是大型对象，与其相关的一些属性将比对象较小时显得更为重要。例如，压缩大型对象（将内存复制到堆上的其他位置）的费用相当高。在本月的专栏中，我将深入探讨大型对象堆。我将讨论符合什么条件的对象才能称之为大型对象，如何回收这些大型对象，以及大型对象具备哪些性能意义。大型对象堆和 GC在 Microsoft® .NET Framewor
WPF中的binding（二）- 使用CLR对象或者对象名称作为Binding的数据源
Hyman的博客
05-12 2728
上一节中主要介绍了在cs代码中进行绑定数据源的实现，后面将逐步介绍下为Binding指定数据源的几种方法。这一节，我们先介绍以CLR对象和对象名称作为Binding的数据源： 一 以CLR对象作为Binding的数据源。          首先，介绍下CLR对象的概念。这里，只是我自己一个简单的理解，并没有涉及CLR很深层次的理论性的东西，因为我也不懂~。在C#中我们会经常看到下面这种类：
CLR的整个类型对象及其工作方法
weixin_30595035的博客
06-19 276
　　下图展示了CLR加载一个进程，在这个进程中，可能存在多个线程。当一个线程创建时，它会分配到一个1MB大小的堆栈，这个堆栈空间用于向方法传递实参，并用于存储在方法内部定义的局部变量。堆栈是从高位内存发址向低位内存地址构建的。在图中，线程执行了一些代码，它的堆栈上已有一些数据。 　　在一个最基本的方法中，应该包含一些“开场白（prologue）”代码，它们负责在方法开始做它的工作前对其进行初...
学习笔记- 类型、方法与继承
qq_25744257的博客
08-23 177
对哇  类型基础知识梳理  类型Type简述 通过本系列前面几篇文章，基本了解了值类型和引用类型，及其相互关系。如下图，.NET中主要的类型就是值类型和引用类型，所有类型的基类就是System.Object，也就是说我们使用FCL提供的各种类型的、自定义的所有类型都最终派生自System.Object，因此他们也都继承了System.Object提供的基本方法。 System.Obje...
学习笔记-架构的演进之初探云原生-3月day04
sinat_22180095的博客
03-06 370
初步认识云原生
SpringBoot3 全栈指南教程——尚硅谷学习笔记 2023年
最新发布
末影小黑xh的博客
09-15 4663
Java17Maven、IDEA1、Spring 使用作为内部日志，但底层日志实现是开放的。可对接其他日志框架。① spring5 及以后 commons-logging 被 spring 直接自己实现了。2、支持jullog4j2logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。3、logback是默认使用的。4、虽然日志框架很多，但是不用担心，使用 SpringBoot 的默认配置就能工作的很好。SpringBoot 怎么把日志默认配置好的。1、每个。
C#自学笔记(崔北为)
03-14
### C#自学笔记知识点梳理 #### 一、C#编程基础 **1.1 概述** C#是一种面向对象的编程语言，由微软开发，主要用于.NET Framework平台上的应用程序开发。它结合了C++和Java的优点，具有简洁、高效、安全性强等特点...
读《周志明的软件架构课》--学习笔记和感想随笔
wangchaodee的博客
03-06 448
主要记录对周老师的《周志明的软件架构课》的学习笔记，本篇章是对课程不可变基础设施部分的学习，从虚拟化的技术理解容器技术的产生和发展，从部署运维角度理解应用的封装，从网络虚拟化理解容器网络，从扩展的角度理解K8s的存储设计，从解耦的角度理解服务网格。从周老师的课程中可以以一种由浅入深的方式来探寻云原生技术的渊源、发展及使用。
机器学习笔记
kaku812814843的博客
05-03 3395
机器学习（machine learning）：用已有的数据训练某种模型，利用模型预测未来 Python机器学习库官网https://scikit-learn.org/stable/ 机器学习分为有监督的机器学习和无监督的机器学习 有监督的机器学习：回归、分类 无监督的机器学习：聚类、降维 numpy数学计算框架 scipy物理计算框架 pandas数据分析框架 matplotlib...
《深入浅出WPF》学习笔记
贵有恒，何必三更眠五更起；最无益，莫过一日曝十日寒
05-03 4203
WPF是什么？ WPF是Windows Presentation Foundation的简称，是用来专门编写程序表示层的技术 1.XAML概览 1.1XAML是什么 XAML(Extensible Application Markup Language):可扩展应用程序标记语言，类似于HTML+CSS+JavaScript的组合 XAML是WPF技术中专门用来设计UI的语言 XAML是...
软考高项-信息系统项目管理师-精华笔记
weixin_44253899的博客
04-16 5998
【人生苦短，只看精华】软考信息系统项目管理师教程共923页，分28章，1264000字。本文取其精华，梳理归纳，分为2个部分介绍重点知识：第1部分：信息系统；第2部分：项目管理。开始画笔记⬇⬇⬇⬇⬇⬇⬇
软考- 高级信息系统项目管理师，第一章 信息化与信息系统
苛学加记事
05-10 7322
第一章 信息化与信息系统 1. 信息系统与信息化 1.1 信息的基本概念 1.1.1 什么是信息 香农指出，信息就是能够用来消除不确定性的东西。 1.1.2 信息质量属性 ① 精确性：对事物状态描述的精准程度。 ② 完整性：对事物状态描述的全面程度，完整信息包括所有重要事实。 ③ 可靠性：值信息的来源、采集方法、传输过程是可以信任的，符合预期的。 ④ 及时性：指获取信息的时刻与事件发生时刻的间隔长短。 ⑤ 经济性：指信息获取、传输带来的成本可以在接受的范围内。 ⑥ 可验证性：指信息的主要质量属性可以被证
第一章 信息化和信息系统 -- 《信息系统项目管理师备考》01
BaymaxCS的博客
01-28 2930
1.信息是什么？ 香农指出“信息就是能够用来消除不确定性的东西”。
CLR学习笔记--深入理解多态机制
July_Lee的专栏
09-05 2189
一、引言 所谓万事开头难，哪怕是写一个学习笔记，以前看惯别人写的博客文章，当时看了就看了，只有一种感觉就是解决了心中的好久疑团，现在自己去写才了解，也许你看了只有短短几分钟，可别人却下了功夫，用了很多心，在此对那些分享文章的朋友表示敬意，想把自己理解的东西写出来十分不易，何况自己可能对写的东西也不自信，害怕自己的错误理解影响了别人，这是十分罪过的，费话不多说，在此表示，在此写的只是自己在学习的过
CLR学习笔记--Attribute
July_Lee的专栏
11-21 1404
一、       引言 利用定制的Attribute,我样可以声明性地为自己的代码添加注解，从而实现一些特殊的功能。定制的Attribute允许将定义的信息应用于几乎每一个元数据表记录项（AttributeTargets枚举了可应用的所有项） 当我们将一个定制的Attribute应用于某个元数据，例如应用于某个类时，则在编译后，会在该类的元数据中的CustomerAttribute“注册表”中
CLR Via C#深度学习笔记
在阅读 Jeffrey Richter 的《CLR Via C#》第二版后，一位程序员记录并分享了他的学习心得，形成了这份深入的读书笔记。笔记主要以作者自己的语言总结了书中的核心见解，旨在与.NET开发者社区分享他从书中汲取的知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值