C#中==运算符

　　在这篇博客中，我们将介绍如下内容：

• ==运算符与基元类型
• ==运算符与引用类型
• ==运算符与String类型
• ==运算符与值类型
• ==运算符与泛型

==运算符与基元类型

　　我们分别用两种方式比较两个整数，第一个使用的是Equals(int)方法，每二个使用的是==运算符：　　

class Program
{
    static void Main(String[] args)
    {
        int num1 = 5;
        int num2 = 5;

        Console.WriteLine(num1.Equals(num2));
        Console.WriteLine(num1 == num2);
    }
}

　　运行上面的示例，两个语句出的结果均为true。我们通过ildasm.exe工具进行反编译，查看IL代码，了解底层是如何执行的。

　　

　　如果您以前从来没有接触过IL指令，不过没关系，在这里您不需要理解所有的指令，我们只是想了解这两个比较方式的差异。

　　您可以看到这样一行代码：

  IL_0008:  call       instance bool [mscorlib]System.Int32::Equals(int32)

　　在这里调用的是int类型Equals(Int32)方法(该方法是IEquatable<Int>接口的实现)。

　　现在再来看看使用==运算符比较生成的IL指令：

  IL_0015:  ceq

　　您可以看到，==运行符使用的是ceq指令，它是使用CPU寄存器来比较两个值。C#==运算符底层机制是使用ceq指令对基元类型进行比较，而不是调用Equals方法。

==运算符与引用类型

　　修改上面的示例代码，将int类型改为引用类型，编译后通过ildasm.exe工具反编译查看IL代码。

class Program
{
    static void Main(String[] args)
    {
        Person p1 = new Person();
        p1.Name = "Person1";

        Person p2 = new Person();
        p2.Name = "Person1";

        Console.WriteLine(p1.Equals(p2));
        Console.WriteLine(p1 == p2);
    }
}

　　上述C#代码的IL代码如下所示：　

　　

　　我们看到p1.Equals(p2)代码，它是通过调用Object.Equals(Object)虚方法来比较相等，这是在意料之中的事情；现在我们来看==运算符生成的IL代码，与基元类型一致，使用的也是ceq指令。

==运算符与String类型

 　　接来下来看String类型的例子：　　

class Program
{
    static void Main(String[] args)
    {
        string s1 = "Sweet";
        string s2 = String.Copy(s1);

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

　　上面的代码与我们以前看过的非常相似，但是这次我们使用String类型的变量。我们建一个字符串，并付给s1变量，在下一行代码我们创建这个字符串的副本，并付给另一个变量名称s2。

　　运行上面的代码，在控制台输出的结果如下：

　　

　　您可以看到ReferenceEquals返回false，这意味着这两个变量是不同的实例，但是==运算符和Equals方法返回的均是true。在String类型中，==运算符执行的结果与Equals执行的结果一样。

　　同样我们使用过ildasm.exe工具反编译查看生成IL代码。

　　

　　在这里我们没有看到ceq指令，对String类型使用==运算符判断相等时，调用的是一个op_equality(string,string)的新方法，该方法需要两个String类型的参数，那么它到底是什么呢？

　　答案是String类型提供了==运算符的重载。在C#中，当我们定义一个类型时，我们可以重载该类型的==运算符；例如，对于以前的例子中我们实现的Person类，如果我们为它重载==运算符，大致的代码如下：

public class Person
{

    public string Name { get; set; }

    public static bool operator ==(Person p1, Person p2)
    {
        // 注意这里不能使用==，否则会导致StackOverflowException
        if (ReferenceEquals(p1, p2))
            return true;

        if (ReferenceEquals(p1, null) || ReferenceEquals(p2, null)) 
            return false; 

          return p1.Name == p2.Name;
    }

    public static bool operator !=(Person p1, Person p2)
    {
        return !(p1 == p2);
    }
}

　　上面的代码很简单，我们实现了==运算符重载，这是一个静态方法，但这里要注意的是，方法的名称是perator ==，与静态方法的相似性；事实上，它们会被由编译器成一个名称为op_Equality()的特殊静态方法。

　　为了使用事情更加清楚，我们查看微软实现的String类型。

　　

　　在上面的截图中，我们可以看到，有两个运算符的重载，一个用于相等，另一个是不等式运算符，其运算方式完全相同，但是否定等于运算符输出。需要注意的一点是，如果您想重载一个类型的==运行符的实现，那么您还需要重载！=操作符的实现，否则编译会报错。

==运算符与值类型

　　 在演示值类型的示例前，我们先将Person类型从引用类型改为值类型，Person定义如下：

public struct Person
{
    public string Name { get; set; }

    public Person(string name)
    {
        Name = name;
    }

    public override string ToString()
    {

        return Name;
    }
}

　　我们将示例代码改为如下：

 class Program
 {
     static void Main(String[] args)
     {
         Person p1 = new Person("Person1");
         Person p2 = new Person("Person2");

         Console.WriteLine(p1.Equals(p2));
         Console.WriteLine(p1 == p2);
     }
 }

 　　当我们在尝试编译上述代码时，VS将提示如下错误：

　　根据错误提示，我们需要实现Person结构体的==运算符重载，重载的语句如下（忽略具体的逻辑）：

 public static bool operator ==(Person p1, Person p2)
 {
 }
 public static bool operator !=(Person p1, Person p2)
 {
 }

 　　当添加上面代码后，重新编译程序，通过ildasm.exe工具反编译查看IL代码，发现值类型==运算符调用也是op_Equality方法。

　　关于值类型，我们还需要说明一个问题，在不重写Equals(object)方法时，该方法实现的原理是通过反射遍历所有字段并检查每个字段的相等性，关于这一点，我们不演示；对于值类型，最好重写该方法。

==运算符与泛型

　　我们编写另一段示例代码，声明两个String类型变量，通过4种不同的方式比较运算：

public class Program
{
    public static void Main(string[] args)
    {
        string str = "Sweet";
        string str1 = string.Copy(str);

        Console.WriteLine(ReferenceEquals(str, str1));
        Console.WriteLine(str.Equals(str1));
        Console.WriteLine(str == str1);
        Console.WriteLine(object.Equals(str, str1));
    }
}

　　输出的结果如下：

　　

　　首先，我们使用ReferenceEquals方法判断两个String变量都引用相同，接下来我们再使用实例方法Equals(string)，在第三行，我们使用==运算符，最后，我们使用静态方法Object.quals(object,object)（该方法最终调用的是String类型重写的Object.Equals(object)方法）。我们得到结论是：

• ReferenceEquals方法返回false，因为它们不是同一个对象的引用；
• String类型的Equals(string)方法返回也是true，因为两个String类型是相同的（即相同的序列或字符）；
• ==运算符也将返回true，因为这两个String类型的值相同的；
• 虚方法Object.Equals也将返回true，这是因为在String类型重写了方法，判断的是String是否值相同。

　　现在我们来修改一下这个代码，将String类型改为Object类型：

public class Program
{
    public static void Main(string[] args)
    {
        object str = "Sweet";
        object str1 = string.Copy((string)str);

        Console.WriteLine(ReferenceEquals(str, str1));
        Console.WriteLine(str.Equals(str1));
        Console.WriteLine(str == str1);
        Console.WriteLine(object.Equals(str, str1));
    }
}

　　运行的结果如下：

　　

　　第三种方法返回的结果与修改之前不一致，==运算符返回的结果是false，这是为什么呢？

　　这是因为==运算符实际上是一个静态的方法，对一非虚方法，在编译时就已经决定用调用的是哪一个方法。在上面的例子中，引用类型使用的是ceq指令，而String类型调用是静态的op_Equality方法；这两个实例不是同一个对象的引用，所以ceq指令执行后的结果是false。

　　再来说一下==运算符与泛型的问题，我们创建一个简单的方法，通过泛型方法判断两个泛型参数是否相等并在控制台上打印出结果：

static void Equals<T>(T a, T b)
{
    Console.WriteLine(a == b);
}

　　但是当我们编译这段代码时，VS提示如下错误：

　　上面显示的错误很简单，不能使用==运算符比较两个泛型T。因为T可以是任何类型，它可以是引用类型、值类型，不能提供==运算符的具体实现。

　　如果像下面这样修改一下代码：

static void Equals<T>(T a, T b) where T : class
{
    Console.WriteLine(a == b);
}

　　当我们将泛型类型T改为引用类型，能成功编译；修改Main方法中的代码，创建两个相同的String类型，和以前的例子一样：　　

public class Program
{
    static void Main(string[] args)
    {
        string str = "Sweet";
        string str1 = string.Copy(str);

        Equals(str, str1);
    }

    static void Equals<T>(T a, T b) where T : class
    {
        Console.WriteLine(a == b);
    }
}

　　输出的结果如下：　　

　　

　　结果与您预期的结果不一样吧，我们期待的结果是true，输出的结果是false。不过仔细思考一下，也许会找到答案，因为泛型的约束是引用类型，==运算符对于引用类型使用的是引用相等，IL代码可以证明这一点：

　　

　　如果我们泛型方法中的==运算符改为使用Equals方法，代码如下：　　

static void Equals<T>(T a, T b)
{
    Console.WriteLine(object.Equals(a, b));
}

 　　我们改用Equals，也可以去掉class约束；如果我们再次运行代码，控制台打印的结果与我们预期的一致，这是因为调用是虚方法object.Equals(object)重写之后的实现。

　　但是其它的问题来了，如果对于值类型，这里就会产生装箱，有没有解决的办法呢？关于这一点，我们直接给出答案，有时间专门来讨论这个问题。

　　将比较的值类型实现IEquatable<T>接口，并将比较的代码改为如下,这样可以避免装箱(关于这一点，可以参考老赵的博客：http://blog.zhaojie.me/2013/04/dont-go-half-way-of-preventing-boxing.html)：

static void Equals<T>(T a, T b)
{
    Console.WriteLine(EqualityComparer<T>.Default.Equals(a, b));
}

 　　

总结

　　对于基元类型==运算符的底层机制使用的是ceq指令，通过CPU寄存器进行比较；

　　对于引用类型==运算符，它也使用的ceq指令来比较内存地址；

　　对于重载==运算符的类型，实际上调用的是op_equality这个特殊的方法；

　　尽量保证==操作符重载和Object.Equals(Object)虚方法的写返回的是相同的结果；

　　对于值类型，Equals方法默认是通过反射遍历所有字段并检查每个字段的相等性，为了提高性能，我们需要重写该方法；

　　值类型默认情况下不能使用==运算符，需要实现==运算符的重载；

　　由于==运算符重载实现实际上是一个静态的方法，在泛型类或方法中使用时与实际的结果可能存在差别，使用Equals方法可以避免这个问题。

  

　　转载请注明出自，原文链接：http://www.cnblogs.com/tdfblog/p/About-Equality-Operator-in-NET.html