C# 使用[=]运算符&；的Int、Char、对象数据类型。等于（）

我对这段代码感到困惑，这两种情况有什么区别？为什么结果不一样

示例编号1

-不具有相同的

数据类型

w/相同的值，但它返回与

true相同的结果

 int value1 = 'a';
 char value2 ='a'; 
 Console.WriteLine(value1 == value2);
 Console.WriteLine(value1.Equals(value2));

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1 == obj2);
Console.WriteLine(obj1.Equals(obj2));

示例编号2

-它们具有相同的

数据类型

w/相同的值，但返回

false和true

 int value1 = 'a';
 char value2 ='a'; 
 Console.WriteLine(value1 == value2);
 Console.WriteLine(value1.Equals(value2));

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1 == obj2);
Console.WriteLine(obj1.Equals(obj2));

示例1

 int value1 = 'a';
 char value2 ='a'; 
 Console.WriteLine(value1 == value2);
 Console.WriteLine(value1.Equals(value2));

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1 == obj2);
Console.WriteLine(obj1.Equals(obj2));

int

的值为

97

，

char

。（见）
两者都是值类型，因此每次都会比较值

示例2

 int value1 = 'a';
 char value2 ='a'; 
 Console.WriteLine(value1 == value2);
 Console.WriteLine(value1.Equals(value2));

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1 == obj2);
Console.WriteLine(obj1.Equals(obj2));

字符串是引用类型。

---

因此，使用

.Equals

比较值（它们是相同的）和

=

比较参考值，它们是不同的。

在你的问题中，在看似简单的代码中实际上发生了很多事情，所以让我们一步一步地处理它。请注意，有太多的事情发生，我可能会错过一些东西，请使用评论字段

第一段代码优先：

int value1 = 'a';
char value2 ='a'; 
Console.WriteLine(value1 == value2);
Console.WriteLine(value1.Equals(value2));

这一行：

int value1 = 'a';

应该给您一个关于此代码行为原因的提示。有一个从

char

到

int

的无声转换。事实上，编译的内容根本没有提到这个变量的

char

，它是一个数字。分配给

int

变量的数字是

a

的代码点值，即97

第一个比较：

value1 == value2

value1.Equals(value2)

obj1 == obj2

使用

int

上的

==

运算符完成，因此在实际中，会进行纯数字比较，就像字符是数字一样。同样的静默转换在这里发生，字符被转换为数字。因为它是相同的字符和相同的转换，所以通过这个比较，您最终也会得到97

:

隐式数字转换为：
…
从

char

到

ushort

，

int

，

uint

，

long

，

ulong

，

float

，

double

或

decimal

这意味着所写内容实际上相当于：

97 == 97

第二个比较：

value1 == value2

value1.Equals(value2)

obj1 == obj2

使用完全相同的转换完成，因此您有：

97.Equals(97)

因此，让我们通过添加显式强制转换并将代码更改为编译器所看到的内容，使第一段代码非常清晰：

// int value1 = (int)'a';                        // 97
int value1 = 97;
char value2 = 'a';
Console.WriteLine(value1 == (int)value);         // 97 == 97
Console.WriteLine(value1.Equals((int)value2));   // 97.Equals(97);

我还要求向我展示这两条语句的反编译：

int a = 97;
int a = 'a';

它们都编译为：

ldc.i4.s 61             // 0x61 = 97

所以需要明确的是，这种静默转换是由编译器完成的，没有运行时代码将字符转换为声明的int，代码执行和编译就像您实际编写的一样

int value1 = 97;

这就是这部分的原因

现在进入下一部分：

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1 == obj2);
Console.WriteLine(obj1.Equals(obj2));

这里首先声明两个

对象

变量，这很重要，然后给它们相同的

字符串

值，尽管它们是两个不同的实例

那么让我们来处理第一个比较：

value1 == value2

value1.Equals(value2)

obj1 == obj2

这是使用为

对象定义的
==
运算符来完成的，该运算符比较引用。因为我们已经确定第二个变量的时髦字符串构造构造了一个新实例，所以引用比较表明它们是不同的

之所以使用在
对象
上定义的
=
运算符，而不是在
字符串
上定义的on运算符，是因为运算符在编译时解析，编译器在编译时只知道变量的类型为
对象
。它们包含字符串的事实，甚至编译器可以“看到”您刚刚为它们分配了字符串，以便它应该使用
字符串
==
运算符的事实，都被忽略

但是，执行此操作时：

obj1.Equals(obj2)

然后调用在
对象
中声明的虚拟
.Equal（object other）
，，它在
字符串中被覆盖，因此得到字符串内容比较，这表明它们是相同的

让我们把第二段代码也说得非常清楚：

object obj1 = "Object One";
object obj2 = new string("Object One".ToCharArray());
Console.WriteLine(obj1.ReferenceEquals(obj2));          // <-- changed
Console.WriteLine(obj1.Equals(obj2));

object obj1=“object One”；
object obj2=新字符串（“object One”.ToCharArray（））；
Console.WriteLine（obj1.ReferenceEquals（obj2））；// 在示例1中，int和char是值类型，因此相等比较（via==或Equals）默认为逐位比较（如文档所示），因为它们都不重写==并且它们的Equals实现将工作委托给==

在这两种情况下都返回true，因为value1和value2具有相同的二进制表示形式

在示例2中，string是一种引用类型，obj1和obj2是对恰好具有相同内容的两个字符串实例的引用

但由于它们被声明为对象，并且==在编译时解析，编译器的唯一选项是发出引用比较（=false）

相反，obj1.Equals实际上是对
string.Equals（object）
的调用，它将返回字符串值的比较

发生了这种情况，因为两者都是值类型，所以不会比较结果为true的引用。要进一步细分，发生的情况如下：

int value1 = 'a';           //First converts to ASCII value 97 and then stored in value1
char value2 ='a';           //Stored as a
Console.WriteLine(value1);  //output is 97
Console.WriteLine(value2);  //output is a
Console.WriteLine(value1 == value2);   //compares using implicit conversion. Since value type, so only value comparison and hence true 
Console.WriteLine('a' == 97);          //compares using implicit conversion.  Since value type, so only value comparison and hence true  
Console.WriteLine(value1.Equals(value2)); //compares using implicit conversion.  Since value type, so only value comparison and hence true 

object obj1 = "Object One";     //string value is stored in Object type variable
object obj2 = new string("Object One".ToCharArray());  //Explicit conversion
Console.WriteLine(obj1);        //Output is Object One
Console.WriteLine(obj2);        //Output is Object One
Console.WriteLine(obj1 == obj2);  //Since == compares both reference and value, hence the false output
Console.WriteLine(obj1.Equals(obj2));  //Equals() compares just the value, hence the true result

示例2-

在这里，您已经手动使用了从Char到String的转换，因此发生了。更进一步地说，发生了这样的事情：

int value1 = 'a';           //First converts to ASCII value 97 and then stored in value1
char value2 ='a';           //Stored as a
Console.WriteLine(value1);  //output is 97
Console.WriteLine(value2);  //output is a
Console.WriteLine(value1 == value2);   //compares using implicit conversion. Since value type, so only value comparison and hence true 
Console.WriteLine('a' == 97);          //compares using implicit conversion.  Since value type, so only value comparison and hence true  
Console.WriteLine(value1.Equals(value2)); //compares using implicit conversion.  Since value type, so only value comparison and hence true 

object obj1 = "Object One";     //string value is stored in Object type variable
object obj2 = new string("Object One".ToCharArray());  //Explicit conversion
Console.WriteLine(obj1);        //Output is Object One
Console.WriteLine(obj2);        //Output is Object One
Console.WriteLine(obj1 == obj2);  //Since == compares both reference and value, hence the false output
Console.WriteLine(obj1.Equals(obj2));  //Equals() compares just the value, hence the true result

这可能是相反的，因为==是静态解析的，将使用引用比较，而Equals是动态解析的dexample2：但是值是相同的，但是使用“==”和.Equals（）的结果是true和false，区别是什么？它不像“每次都比较值”那么简单，char和int由compi提供神奇的支持