有哪位大神可以详细讲解一下如何判断两个对象是否相同~~~~

   static void Main(string[] args)
        {
            string a = Console.ReadLine();
            string b = Console.ReadLine();   //获取用户输入的值

            bool bo = true;                //定义一个bool 值来进行判断
            bo=a == b;                     // 如果a等于b 是true
            if (bo) //判断bo是true
            {
                Console.WriteLine("{0}等于{1}",a,b);//相等
            }
            else//否则不相等
            {
                Console.WriteLine("{0}不等于{1}",a,b);
            }
        }

例如你有一个类如下：public class Class1{    private int m;    private string n;    public int M    {        set { m = value; }        get { return m; }    }    public string N    {        set { n = value; }        get { return n; }    }    public override bool Equals(object obj)    {        Class1 anotherClass = obj as Class1;        if (anotherClass != null)            return (                this.m == anotherClass.m &&                this.n.Equals(anotherClass.n));        else            return false;    }    public override int GetHashCode()    {        return base.GetHashCode();    }public Class1()    {    }}如果你要比较两个类是否相等，需要在类里面override Equal方法，就如上面的例子那样。。 override Equal方法的同时需要override GetHashCode方法。这样，你就可以比较这个类的两个对象是否相等了。例如        Class1 class1 = new Class1();        class1.M = 1;        class1.N = "a";        Class1 class2 = new Class1();        class2.M = 1;        class2.N = "a";        bool isEqual = class1.Equals(class2);这个时侯isEqual就会返回true当然这是你的自定义类。如果你只是比较.net的类对象，那就是Equal方法就可以了。。 override Equal方法其实会是一个比较复杂的方法。使用时需要慎重。。特别是你的类里面本身还有很多复杂对象的时候。需要考虑完整。否则你的比较结果会是不准确的。

ljh4282158 发表于 2013-6-12 11:09
static void Main(string[] args)
        {
            string a = Console.ReadLine();

这个太简陋了点吧~~~~~~{:3_69:}

.Net中主要有四种相等比较，分别是：==操作符、Object.Equals方法、Object.ReferenceEquals方法、对象实例的Equals方法。

Object的两个静态方法：
ReferenceEquals方法是比较两个对象的引用是否相同，即栈上的地址是否一样，对于值类型没有意义参数中若有值类型参数出现，必定返回false
Object的Equals静态方法实际上是对实例Equals方法的扩展，增加了null的判断，适应于比较两个可能为空引用的对象

== ：
对于引用类型==和ReferenceEquals静态方法作用相同
对于一些原生值类型，如int,long,char等，==是直接比较其数值而且不同类型间可以互相比较，比如int和char，'A’==65返回的是True
而对于一般的Struct，如果没有在代码中定义==（也包括!=)操作符，是不能用==比较的
使得String类型像原生值类型一样按值比较

Equals：
这是个Virtual方法，是我们在应用开发中，经常要根据业务逻辑需要，进行覆写的方法

你可以看看这个：http://www.cnblogs.com/XmNotes/archive/2011/06/23/2088341.html

胡章诚 发表于 2013-6-12 11:15
.Net中主要有四种相等比较，分别是：==操作符、Object.Equals方法、Object.ReferenceEquals方法、对象实例 ...

是不是可以说：在任何时候想比较两个对象的地址是否一样，可以使用object的ReferenceEquals()方法

        static void Main(string[] args)
        {
            string a = "a";
            string b = "a";
            Console.WriteLine(a==b);//判断字符串是否一样
            Console.WriteLine(a.Equals(b));//判断字符串是否一样
            Console.WriteLine(string.ReferenceEquals(a,b));//判断是否同一个堆地址
        }

彭康 发表于 2013-6-12 11:21
static void Main(string[] args)
        {
            string a = "a";

这三个应该都为True吧~~~

yangaidongcumt 发表于 2013-6-12 11:29
这三个应该都为True吧~~~

哈哈恭喜答对了，可惜没技术分奖你

yangaidongcumt 发表于 2013-6-12 11:18
是不是可以说：在任何时候想比较两个对象的地址是否一样，可以使用object的ReferenceEquals()方法 ...

如果是引用类型，可以用这个比较一般是同一个对象才会 返回true
但是如果是值类型，直接返回false，
所以object的ReferenceEquals()没有太大意义，一般用于测试

彭康 发表于 2013-6-12 11:34
哈哈恭喜答对了，可惜没技术分奖你

==和Equlas是一样的，可以用来比较对象是否相同，但是不能够用来比较字符串对象是否相同，因为string类的Equals方法重写了object类的Equals方法，只能用来比较字符串值是否一样，第三个方法是任何时候都可以使用的比较两个对象是否相同，之所以第三个也为True，是因为字符串池的原因，b并没有重新创建了一个对象，而是直接用a的那个“a”,我理解的对么~~~~

说白了，在C#中可以概括两种比较相等：1、值的相等； 2、引用的相等（引用同一个地址，值肯定也相等）。

yangaidongcumt 发表于 2013-6-12 12:06
==和Equlas是一样的，可以用来比较对象是否相同，但是不能够用来比较字符串对象是否相同，因为string类的 ...

完全正确，这些在基础加强里面说的很详细

参考这个：http://hi.baidu.com/little_grass/item/6280533a0658dc89f5e4adca

C#中对象的四种相等比较方式如下：
1.ReferenceEquals(object o1, object o2)：比较两个对象的引用，引用相同返回true，否则返回false，同为null是返回true；
2.Equals(object o)：虚拟Equals方法，比较引用，可以重写比较值；
3.Equals(object o1, object o2)：静态Equals方法，先判断两个对象是否为空，如果都不为空，则调用虚拟Equals方法；
4.object1 == object2：比较运算符，比较引用,可以重写；

注意：值类型比较时应采用重写后的Equals方法，使用ReferenceEquals进行值类型比较时总是返回false，因为两个值类型需要分别装箱到对象中，是不同的引用

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

namespace Magic.Test.Operators
{

    public class SomeClass
    {
         
    }
  
    public class TestEquals
   {
        public static void Main()
       {
            SomeClass s1 = new SomeClass();
            SomeClass s2 = new SomeClass();
            SomeClass s3 = s1;
  
            //ReferenceEquals比较两个对象的引用，同为null是返回true
            Console.WriteLine("ReferenceEquals(s1, s2) : " + ReferenceEquals(s1, s2));
            Console.WriteLine("ReferenceEquals(null, null) : " + ReferenceEquals(null, null));
            Console.WriteLine("ReferenceEquals(s1, null) : " + ReferenceEquals(s1, null));
              
            //虚拟Equals方法，比较引用，可以重写比较值
            Console.WriteLine("s1.Equals(s2) : " + s1.Equals(s2));
            Console.WriteLine("s1.Equals(s3) : " + s1.Equals(s3));
            
            //静态Equals方法先比较两个对象是否为空，如果都不为空，则调用虚拟Equals方法
            Console.WriteLine("SomeClass.Equals(s1, s2) : " + SomeClass.Equals(s1, s2));
            Console.WriteLine("SomeClass.Equals(null, null) : " + SomeClass.Equals(null, null));
            Console.WriteLine("SomeClass.Equals(s1, null) : " + SomeClass.Equals(s1, null));
           
            //比较运算符比较引用,可以重写
            Console.WriteLine("s1 == s2 : " + (s1 == s2));
            Console.WriteLine("s1 == s3 : " + (s1 == s3));

            //值类型比较
            Console.WriteLine("1.Equals(1) : " + 1.Equals(1));
            //ReferenceEquals进行值类型比较时总是返回false，因为两个值类型需要分别装箱到对象中，是不同的引用
            Console.WriteLine("ReferenceEquals(1, 1) : " + ReferenceEquals(1, 1));
        }
    }
}