C#判等对象是否相等的方法汇总

本文以实例形式展示了c#判等对象是否相等的常用方法，非常实用，可供大家参考借鉴之用。具体分析如下：

一、判断相等的3个方法

1.实例方法

public virtual bool equals(object obj) 
{ 
  return runtimehelpers.equals(this, obj); 
}

2.比较值类型静态方法

public static bool equals(object obja, object objb) 
{ 
  return ((obja == objb) || (((obja != null) && (objb != null)) && obja.equals(objb))); 
}

3.比较引用类型静态方法

public static bool referenceequals(object obja, object objb) 
{ 
  return (obja == objb); 
}

二、判断引用类型是否相等

  class program 
  { 
    static void main(string[] args) 
    { 
      team t1 = new team("马尔切洛·里皮"); 
      team t2 = new team("马尔切洛·里皮"); 
      var result = (t1 == t2); 
      console.writeline(result); 
      result = t1.equals(t2); 
      console.writeline(result); 
      console.readkey(); 
    } 
  }
 
  public class team 
  { 
    public string _coach = string.empty;
 
    public team(string coach) 
    { 
      this._coach = coach; 
    } 
  }
 
  public struct teamstruct 
  { 
    public string _coach;
 
    public teamstruct(string coach) 
    { 
      this._coach = coach; 
    } 
  }
 

运行结果：

false
false

分析：引用类型比较的是引用地址，由于t1和t2指向不同的对象实例，所以dou都返回false。  

三、判断值类型是否相等

1.值类型判断方法

派生于system.valuetype，对system.object中的虚方法equals(object obj)进行了重写

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)) //对象成员如果存在对于堆的引用返回false 
  { 
    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]).unsafegetvalue(a); 
    object obj4 = ((rtfieldinfo) fields[i]).unsafegetvalue(obj); 
    if (obj3 == null) 
    { 
      if (obj4 != null) 
      { 
        return false; 
      } 
    } 
    else if (!obj3.equals(obj4)) 
    { 
      return false; 
    } 
  } 
  return true; 
}

2.用==判断是否相等

    static void main(string[] args) 
    { 
      teamstruct ts1 = new teamstruct("马尔切洛·里皮"); 
      teamstruct ts2 = ts1; 
      var result = (ts1 == ts2); 
      console.writeline(result); 
      console.readkey(); 
    }

出现编译错误。原因是值类型不能用==进行判断。

3.用equals()实例方法判断是否相等

    static void main(string[] args) 
    { 
      teamstruct ts1 = new teamstruct("马尔切洛·里皮"); 
      teamstruct ts2 = ts1; 
      var result = ts1.equals(ts2); 
      console.writeline(result); 
      console.readkey(); 
    }

返回true。

可见，如果值类型的字段相等，那就相等。

    static void main(string[] args) 
    { 
      teamstruct ts1 = new teamstruct("马尔切洛·里皮"); 
      teamstruct ts2 = ts1; 
      ts2._coach = "高洪波"; 
      var result = ts1.equals(ts2); 
      console.writeline(result); 
      console.readkey(); 
    }

返回false,当然，值类型的字段有不相等，就会整个不相等。

4.判断复杂值类型是否相等

即值类型中包含引用类型和值类型。

  class program 
  { 
    static void main(string[] args) 
    { 
      team t = new team("马尔切洛·里皮"); 
      teamstruct ts = new teamstruct("马尔切洛·里皮");
 
      nationalteam nt1 = new nationalteam(t, ts); 
      nationalteam nt2 = nt1; 
      var result = nt1.equals(nt2); 
      console.writeline(result); 
      console.readkey(); 
    } 
  }
 
  public class team 
  { 
    public string _coach = string.empty;
 
    public team(string coach) 
    { 
      this._coach = coach; 
    } 
  }
 
  public struct teamstruct 
  { 
    public string _coach;
 
    public teamstruct(string coach) 
    { 
      this._coach = coach; 
    } 
  }
 
  public struct nationalteam 
  { 
    public team _team; 
    public teamstruct _structteam;
 
    public nationalteam(team team, teamstruct structteam) 
    { 
      this._team = team; 
      this._structteam = structteam; 
    } 
  }
 

返回true，会遍历比较引用类型成员和值类型成员。在nt1和nt2中，类型为team的引用类型成员_team指向同一个对象实例，  类型为teamstruct的值类型成员_structteam相等，所有整个返回。如下图所示：