using System;
using System.Collections.Generic;
using System.Text;
namespace AboutEquals
{
//http://net.itcast.cn/ViewArticle-57.aspx
#region 引用相等性，即同一性 （一）
//class Test
//{
// static void Main()
// {
// Test1 a = new Test1(1, "Hi");
// Test1 b = new Test1(1, "Hi");
// bool areEqual = System.Object.ReferenceEquals(a, b);//创建了两个对象
// System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual); // False 引用内存中的不同基础对象
// b = a;//赋值
// areEqual = System.Object.ReferenceEquals(a, b);//引用内存中的相同基础对象
// System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual);//True
// System.Console.WriteLine("ReferenceEquals(1, 1) = {0}", System.Object.ReferenceEquals(1, 1));//False 每个变量都会被装箱到单独的对象实例中,因此值类型对象无法具有引用相等性
// Console.WriteLine("Press any key to exit.");
// Console.ReadKey();
// }
//}
//class Test1
//{
// public int Num;
// public string Str;
// public Test1(int num, string str)
// {
// this.Num = num;
// this.Str = str;
// }
//}
#endregion
#region 引用相等性，即同一性 以及 值相等性 （二）
//struct TestStruct
//{
// public int Num;// { get; private set; }
// public string Name;//{ get; private set; }
// public TestStruct(int i, string s)
// : this()
// {
// Num = i;
// Name = s;
// }
//}
//class TestClass
//{
// public int Num;
// public string Name;
// public TestClass(int a, string b)
// {
// this.Num = a;
// this.Name = b;
// }
//}
//class Test
//{
// static void Main()
// {
// #region ReferenceTypes 测试引用相等性
// TestClass tcA = new TestClass(1, "New TestClass");
// TestClass tcB = new TestClass(1, "New TestClass");
// Console.WriteLine("ReferenceEquals(tcA, tcB) = {0}", Object.ReferenceEquals(tcA, tcB)); // false
// tcB = tcA;
// Console.WriteLine("After asignment: ReferenceEquals(tcA, tcB) = {0}", Object.ReferenceEquals(tcA, tcB)); // true
// tcA.Num = 42;
// tcA.Name = "TestClass 42";
// Console.WriteLine("tcB.Name = {0} tcB.Num: {1}", tcB.Name, tcB.Num);// 42,"TestClass 42"
// #endregion
// #region ValueTypes 测试值相等性
// TestStruct tsC = new TestStruct(1, "TestStruct 1");
// // Value types are copied on assignment. tsD and tsC have the same values but are not the same object.
// // 值类型被复制，tsD与tsC有相同的值，但对象却不同 注：由于在将值类型的实例赋给变量时将建立值的副本，因此值类型对象无法具有引用相等性
// // 永远不能有引用内存中的同一位置的两个未装箱结构，因为每个变量都会被装箱到单独的对象实例中
// TestStruct tsD = tsC;
// Console.WriteLine("After asignment: ReferenceEquals(tsC, tsD) = {0}", Object.ReferenceEquals(tsC, tsD)); // false
// #endregion
// #region stringRefEquality
// //对于String类，默认的相同的字符串在堆上只保留一个Copy，所以strA与strB指向同一地址
// string strA = "Hello world!";
// string strB = "Hello world!";
// Console.WriteLine("ReferenceEquals(strA, strB) = {0}", Object.ReferenceEquals(strA, strB)); // true
// //字符串不再相同，不再指向同一地址
// //当我们改变string值的时候，便会在托管堆上重新分配一块新的内存空间，而不会影响到原有的内存地址上所存储的值。
// strA = "Goodbye world!";
// Console.WriteLine("strA = /"{0}/" strB = /"{1}/"", strA, strB);
// Console.WriteLine("After strA changes, ReferenceEquals(strA, strB) = {0}", Object.ReferenceEquals(strA, strB)); // false
// // 动态生成的字符串,这样的字符串是不会添加到缓存哈希表中进行维护的
// StringBuilder sb = new StringBuilder("Hello world!");
// string stringC = sb.ToString();
// /*在CLR被加载之后，便SystemDomain所对应的托管堆中初始化了一个HashTable。这个HashTable的目的就是为了存储我们所创建过的字符串。
// 在Hashtable中，Key是string的内容，Value是这个字符串所对应的内存地址
// 当初始化一个字符串时，会首先在这个系统初始化的HashTable中查找每一个字符串常量在HashTable中是否存在，不存在它将分配一块内存地址来存储这个字符串常量，然后在HashTable中
// 增加一个键值对，将字符串的内容存为key,而将分配的内存地址存为Value
// */
// // False 此时的stringC是动态生成的字符串,这样的字符串是不会添加到缓存哈希表中进行维护的
// Console.WriteLine("ReferenceEquals(stringC, strB) = {0}", Object.ReferenceEquals(stringC, strB));
// //我们可以使用Intern搜索整个Hashtable,找是否有这个字符串的相关引用，如果找到了它便会将这个引用返回给stringC
// Console.WriteLine("ReferenceEquals(stringC, strB) = {0}", Object.ReferenceEquals(String.Intern(stringC), strB));//true
// // The string class overloads the == operator to perform an equality comparison.
// Console.WriteLine("stringC == strB = {0}", stringC == strB); // true
// #endregion
// // Keep the console open in debug mode.
// Console.WriteLine("Press any key to exit.");
// Console.ReadKey();
// }
//}
#endregion
#region Equals,==,ReferenceEquals区别
class Test
{
public static void Main(string[] args)
{
//string a = "Hello World";
//string b = "Hello World";
//StringBuilder sb = new StringBuilder("Hello world!");
//string c = sb.ToString();
//Console.WriteLine(Object.Equals(a, b));
//Console.WriteLine(Object.Equals(a, c));
TestStruct tsC = new TestStruct(1, "TestStruct 1");
TestStruct tsD = tsC;
Console.WriteLine("After asignment: Equals(tsC, tsD) = {0}", Object.Equals(tsC, tsD));
//Console.WriteLine("After asignment: ReferenceEquals(a, b) = {0}", Object.ReferenceEquals(a, "Hello " + "World"));
//Console.WriteLine("After asignment: Equals(a, b) = {0}", Object.Equals(a, "Hello " + "World"));
//string peom1 = "Kubla Khan";
//string peom2 = "Kubla Khan";
//string peom3 = String.Copy(peom2);
//string peom4 = "kubla khan";
ReferenceEquals()判断两个字符串是否指向相同的内存地址
//Console.WriteLine("peom1 == peom2:" + (peom1 == peom2));//True
//Console.WriteLine("peom1 == peom3:" + (peom1 == peom3));//True
//Console.WriteLine("ReferenceEquals(peom1,peom3):" + ReferenceEquals(peom1, peom3));//False
Equals,先判断两个字符串有相同的内存位置，则两个字符串相等；否则逐字符比较两个字符串，判断是否相等
//Console.WriteLine("Equal(peom1,peom3):" + String.Equals(peom1, peom2));//true
//Console.WriteLine("Equal(peom1,peom3):" + String.Equals(peom1, peom3));//true
//ReferenceEquals已知 用于引用类型
/*" == "
*
* 用于引用类型与值类型：
*
* 对于内置的值类型，它判断的是两个对象的值是否相等，它会根据需要进行必要的类型转换，并根据两个对象的值是否相等判断是true还是false
*
* 对于用户定义的值类型，如果没有重载操作符==，==将不能使用
*
* 对于引用类型，== 默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。但是.NET Framework中的
* 类很多对==进行了重载，例如String类的==与Equals的行为相同，判断两个字符串的内容是否相等。所以在应用中，对于系统定义的引用类型建议
* 不要使用==操作符，以免程序出现与预期不同的运行结果。
*
*
* 引用类型最好不要重载定义==操作符
*
* http://blog.csdn.net/wuchen_net/archive/2010/03/23/5409327.aspx
*
* 重载形式：
* public static bool operator == ( KeyData left, KeyData right );
* public struct KeyData
* {
* public int data;
* public int Data
* {
* set
* {
* data = value;
* }
* get
* {
* return data ;
* }
* }
* public static bool operator ==(KeyData left,KeyData right)
* {
* return left.data==right.data;
* }
* public static bool operator !=(KeyData left,KeyData right)
* {
* return left.data!=right.data;
* }
* }
*
* 由于==操作与!=操作要同步定义，所以在定义==重载函数的时候，也要定义!=重载函数。这也是.Net在判等操作保持一致性。那么对于最后一个
* 判等函数，这种重载运算符的方法并不适合引用类型。这就是.Net经常现象，去判断两个引用类型，不要用==，而要用某个对象的Equals函数。
* 所以在编写自己类型的时候，要保留这种风格。
*
*/
//测试值类型：
//int a = 3;
//double b = 3.0;
//Console.WriteLine(a == b);//true
/*"Equals"
*
* 用于引用类型与值类型：
*
* Equals方法对于值类型和引用类型的定义不同，对于值类型，类型相同，并且数值相同(对于struct的每个成员都必须相同)，则Equals返回 true,
* 否则返回false。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时 候才返回true。可以根据
* 需要对Equals进行重载，例如String类的Equals用于判断两个字符串的内容是否相等。
*
*
* 静态的Equals()方法：
*
* Equals()的静态版本与其虚拟实例版本的作用相同，其区别是静态版本带有两个参数，并对它们进行相等比较。这个方法可以处理两个对象中有一
* 个是null的情况，因此，如果一个对象可能是null，这个方法就可以抛出异常，提供了额外的保护。静态重载版本首先要检查它传送的引用是否为
* null。如果它们都是null，就返回true(因为null与null相等)。如果只有一个引用是null，就返回false。如果两个引用都指向某个对象，它就调用
* Equals()的虚拟实例版本。这表示在重写Equals()的实例版本时，其效果相当于也重写了静态版本。以下是其执行步骤,一共三个步骤：
*
* public static bool Equals( object left, object right );
* 按照书中对它的分析，其大致函数代码如下：
* public static void Equals( object left, object right )
* {
* 第一步是需要根据对象所属类型的==操作符的执行结果
* if(left==right)
* {
* return true;
* }
* 第二步是判别是否为null
* if(left==null&&right==null)
* {
* return true;
* }
* 最后一步要使用到虚拟的Equals函数的执行结果
* return left.Equals(right);
*
* }
*
* 虚拟的Equals()方法：
*
* Equals()虚拟版本的System.Object实现代码也比较引用。但因为这个方法是虚拟的，所以可以在自己的类中重写它，按值来比较对象。特别是如果
* 希望类的实例用作字典中的键，就需要重写这个方法，以比较值。否则，根据重写Object.GetHashCode()的方式，包含对象的字典类要么不工作，要
* 么工作的效率非常低。在重写Equals()方法时要注意，重写的代码不会抛出异常。这是因为如果抛出异常，字典类就会出问题，一些在内部调用这个
* 方法的.NET基类也可能出问题。以下是一个Equals方法重写的例子：
*
* public override bool Equals(object right)
* {
* if(right==null)
* {
* return false;
* }
* if(object.ReferenceEquals(this,right))
* {
* return true;
* }
* 该方法是重写新增的
* if(right.GetType()==this.GetType())
* {
* return true;
* }
* }//详细见http://www.cnblogs.com/happygoodluck/archive/2010/08/08/1795007.html
*
* 除此外对于类型的Equals函数来，其实并没有限制类型非要属于引用类型，对于值类型也是可以重载此函数，但是我并不推荐，主要是Equals函数的
* 参数类型是不可变的，也就是说通过此方法，值类型要经过装箱操作，而这是比较影响效率的。
*
*
*
*
*
*
*
*
*/
int n = 10;
double t = n;
Console.WriteLine(Object.Equals(10.0, t));
Console.ReadKey();
}
}
#endregion
}
扫一扫
241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
