你不知道的东西!c#==等于运算符和Object.Equals()

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› c#›C#教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

最近在看高级点的程序员必看的 CLR via C# 书中说解释了 Object.Equals() 方法的实现, 其中具体的实现用的是 == 运算符 !

以前就对 == 运算符的具体实现产生过疑惑 . 它到底对比的什么?

今天刚好手头的东西弄完了,而且还得强制加班中 ! 所以就那今天的加班时间来认真来看一下 == 运算符 !

最早对于 == 和 Object.Equals() 的了解是来源于很早以前的一次面试上面的面试题就有这个问题, 非常遗憾是当时我水平有限恰好不知道怎么回答. 没有回答上来回家后开始百度一下答案看的是迷迷糊糊的. 有好几种说法. 当时也没太在意找个了最主流的就认为是 "真理" 了!
阅读 CLR via C# 了解底层实现时有看到了 Object.Equals() 看到了内部使用的是 == 运算符进行的比较我对以前的标准答案和 CLR via C# 书中所说的答案都持有怀疑态度然后找证据进行研究.我只相信我看到的. 我也庆幸自己真的看到了.

因为是 Object.Equals() 这方法产生的疑问所以吧这个内部实行帖出来

        public static bool Equals(object objA, object objB)
        {
            return ((objA == objB) || (((objA != null) && (objB != null)) && objA.Equals(objB)));
        }
         //  他首先使用了 == 符号进行对比  然后又 使用对象自己 的 Equals 进行对比

Ps objA.Equals方法得解释一下 . objA使用的Equals方法是类型自己可能会重写父类的 Equals 的这个方法.

等于到底做了什么?

关于怎么实现的非常抱歉的说我并没有找到 == 运算符的具体实现代码.

但是可以再MSDN 上看到它到底干了什么.

http://msdn.microsoft.com/zh-cn/library/53k8ybth.aspx

== 比较字符串的值。

通过MSDN 上的解释我们可以看到好像是它很厉害能过自动通过类型进行不同的对比.

其实并未如此

回到我们的更本问题 : == 运算符对比的到底什么?

如果你了解栈和托管堆那么你一定知道数据字节一定不是放在栈中就是放在托管堆中所以 == 运算符对比不是对比的栈中的数据就是对比的托管堆中是数据可以你觉得我说废话了,但是还是要交代清楚:

我们来看一段简单的代码

   class Program
    {
        static void Main(string[] args)
        {
            Class2 s1 = new Class2();
            Class2 s2 = new Class2();
            Console.WriteLine(s1 == s2 ? "True" : "false");
        }
    }
    public class Class2
    {
    }

大家猜一下是 Ture 还是 False

答案是 False ;

想一下如果是对比的是托管堆中的话那么他们都是创建了该对象的 "逐层父类" "类型对象指针" "同步快索引" 等 ;

代码中创建的是一样的那么托管堆中的数据就是一样的如果是对比的托管堆那么返回就是 true 显然程序返回的是 False

而且!　

值类型　是存放在　栈　中的　托管堆中并没有东西．　所以　对比　只能是对比　栈中的数据．

说了一堆　就是想先解释清楚　＝＝　运算符对比的是　栈　为什么对比是　栈　而不是托管堆！　我喜欢说的详细点　虽然你可以能觉得啰嗦，我也得巧更多的键盘．但是我认为只有写的很详细了　观看的人才会容易理解．

下面做一些　ＭＳＤＮ　上　＝＝　运算符　对比类型的解释

值类型，ＭＳＤＮ上是　预定义的值类型　　其实就是他本身只带的值类型　上面的结论是　＝＝对比是　栈　值类型的对比就没什么说的了
string 以外的引用类型　　他们都有一个特定　那就是他们都是Object 的派生类. 栈中放入的是托管堆中的是地址指向. 那么栈中是地址指向由于== 是对比的栈后面的就不用说多了吧
string 类型都说它是个特殊类型我觉得是以为微软对其做的 "stirng池" 定义一个 string 变量并且给它赋值的时候会先检查 "stirng池" 中是是否已经有了同样的的内存数据. 如果True 则将这个内存地址的指针赋值给栈中的变量名称.

string 类型重写了 == 运算符将其使用了 string 类重写的 Equals 方法进行对比;

具体代码段:

        public static bool Equals(string a, string b)
        {
            return ((a == b) || (((a != null) && (b != null)) && EqualsHelper(a, b)));
        }  
        public static bool operator ==(string a, string b)
        {
            return Equals(a, b);
        }
        
        public static bool operator !=(string a, string b)
        {
            return !Equals(a, b);
        }

关键是 EqualsHelper 这个方法

 private static unsafe bool EqualsHelper(string strA, string strB)
        {
            int length = strA.Length;
            if (length != strB.Length)
            {
                return false;
            }
            fixed (char* str = ((char*) strA))
            {
                char* chPtr = str;
                fixed (char* str2 = ((char*) strB))
                {
                    char* chPtr2 = str2;
                    char* chPtr3 = chPtr;
                    char* chPtr4 = chPtr2;
                    while (length >= 12)
                    {
                        if (((*(((long*) chPtr3)) != *(((long*) chPtr4))) || (*(((long*) (chPtr3 + 4))) != *(((long*) (chPtr4 + 4))))) || (*(((long*) (chPtr3 + 8))) != *(((long*) (chPtr4 + 8)))))
                        {
                            break;
                        }
                        chPtr3 += 12;
                        chPtr4 += 12;
                        length -= 12;
                    }
                    while (length > 0)
                    {
                        if (*(((int*) chPtr3)) != *(((int*) chPtr4)))
                        {
                            break;
                        }
                        chPtr3 += 2;
                        chPtr4 += 2;
                        length -= 2;
                    }
                    return (length <= 0);
                }
            }
        }

它将其每个字符串全部取出单个进行对比. 所有 CLR via C# 中说是对比的同等性

现在 == 运算符的问题都解开了疑惑了

那么让我们重新看一下 Object.Equals 这个方法

         public static bool Equals(object objA, object objB)
        {
            return ((objA == objB) || (((objA != null) && (objB != null)) && objA.Equals(objB)));
        }

这段代码我们前面就看过是 Object.Equals 是代码, 让我们再次解释一下

1 现将比对的对象封装成跟类型也就是Object 类在说一遍封装又得讲很多简略一下就是两个对象如果是值类型就将其通过分装成Object 转换为引用类型将其通过==运算符对比栈中的指向内存的指针.
```
            int s1 = 1;
            int s2 = 1;
            object o1 = (object) s1;
            object o2 = (object) s2;
            Console.WriteLine(o1==o2? "true":"fales");
```
这段代码返回的永远都是 Fales
2 然后进行是否非空的验证

3 调用 objA 对象的Equals 方法 . 这里是关键 ! 因为这里调用的并不是 Object类的 Equals 方法而是当前传递过来的对象类类型的Equals 方法!

几乎所有 类型都会重写 Object 根类的 Equals 即便是当前对象没有重写 那么父类也会重写Object 的 Equals 方法 如 所有值类型对象的根类  System.ValueType   重写了 Equals 方法

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            RuntimeType type = (RuntimeType) base.GetType();
            RuntimeType type2 = (RuntimeType) obj.GetType();
            if (type2 != type)
            {
                return false;
            }
            object a = this;
            if (CanCompareBits(this))
            {
                return FastEqualsCheck(a, obj);
            }
            FieldInfo[] fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
            for (int i = 0; i < fields.Length; i++)
            {
                object obj3 = ((RtFieldInfo) fields[i]).InternalGetValue(a, false);
                object obj4 = ((RtFieldInfo) fields[i]).InternalGetValue(obj, false);
                if (obj3 == null)
                {
                    if (obj4 != null)
                    {
                        return false;
                    }
                }
                else if (!obj3.Equals(obj4))
                {
                    return false;
                }
            }
            return true;
        }

这是具体实现代码看的很明显是通过反射获取对象的值进行对比也就的对比的相等性

但是 !　我们经常使用的　一些　．ｎｅｔ预定义的类　几乎还会接着重写这个方法　

如　int32

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public override bool Equals(object obj)
        {
            return ((obj is int) && (this == ((int) obj)));
        }
        
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public bool Equals(int obj)
        {
            return (this == obj);
        }