在这里，我们将给大家分享关于C#正确实现Equals方法,如何实现GetHashCode方法的知识，同时也会涉及到如何更有效地c#–EqualsistencyinEquals和GetHashCode方
在这里，我们将给大家分享关于C#正确实现Equals方法,如何实现GetHashCode方法的知识，同时也会涉及到如何更有效地c# – Equalsistency in Equals和GetHashCode方法、c# – 为什么不应该使用反射来实现Equals和GetHashCode？、c# – 如何使用覆盖逻辑Equals()实现GetHashCode()的覆盖、Effective-Java读书笔记09 Always override hashCode when you override equals 重写equals方法时一定要重写hashCode方法的内容。
本文目录一览：- C#正确实现Equals方法,如何实现GetHashCode方法
- c# – Equalsistency in Equals和GetHashCode方法
- c# – 为什么不应该使用反射来实现Equals和GetHashCode？
- c# – 如何使用覆盖逻辑Equals()实现GetHashCode()的覆盖
- Effective-Java读书笔记09 Always override hashCode when you override equals 重写equals方法时一定要重写hashCode方法
C#正确实现Equals方法,如何实现GetHashCode方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Crystal_Message
{
class Person
{
private string firstName ="";
private string lastName= "";
private string phone="";
public Person(string firstName,string lastName,string phone)
{
this.FirstName = firstName;
this.LastName = lastName;
this.PhoneNumber = phone;
}
public string FirstName
{
get { return firstName; }
private set
{
if (string.IsNullOrWhiteSpace(value)){
throw new ArgumentNullException("Must Include First Name");
}
this.firstName = value;
}
}
public string LastName
{
get { return lastName; }
private set
{
if (string.IsNullOrWhiteSpace(value)){
throw new ArgumentNullException("Must Include Last Name");
}
this.lastName = value;
}
}
public string PhoneNumber
{
get { return phone; }
private set
{
if (string.IsNullOrWhiteSpace(value)){
throw new ArgumentNullException("Must Include Phone Number");
}
this.phone = value;
}
}
public override string ToString()
{
return "First Name: " + this.FirstName + " " + " Last Name: " + this.LastName + " " + " Phone Number: " + this.PhoneNumber;
}
public override bool Equals(object obj)
{
if(obj == null)
{
return false;
}
Person testEquals = obj as Person;
if((System.Object)testEquals == null)
{
return false;
}
return (this.firstName == testEquals.firstName) && (this.lastName == testEquals.lastName) && (this.phone == testEquals.phone);
}
/*
public override int GetHashCode()
{
return
}
*/
}
}
我在MSDN之前遵循了这些指导原则.两个问题：
>我是否正确实施了equals方法？
>有人能告诉我如何正确地为我的班级实现GetHashCode吗？ MSDN做x ^ y,但我不能为我做.
解决方法
所以在你的情况下：
public override int GetHashCode()
{
return firstName.GetHashCode() ^ lastName.GetHashCode() ^ phone.GetHashCode();
}
c# – Equalsistency in Equals和GetHashCode方法
sbyte i = 1; int j = 1; object.Equals(i,j) //false (1) object.Equals(j,i) //false (2) i.Equals(j) //false (3) j.Equals(i) //true (4) i == j //true (5) j == i //true (6) i.GetHashCode() == j.GetHashCode() //false (7)
(3)和(4)之间的差异打破了等于对称的要求.
>(2)和(4)之间的区别与MSDN specification不一致：
If the two objects do not represent the same object reference and
neither is null,it calls objA.Equals(objB) and returns the result.
This means that if objA overrides the Object.Equals(Object) method,
this override is called.
>(3)和(5)之间的区别意味着operator ==返回true,但是对象在Equals方面不相等.
>(4),(5),(6)和(7)之间的区别意味着两个对象在operator ==和Equals方面相等,但是它们具有不同的哈希码.
我非常感兴趣,如果有人可以解释为什么在我看来,在相当基本的.NET类型中观察到不一致的行为.
解决方法
其他比较工作在一个int和一个sbyte,根据定义是不同的. j.Equals(i)转到重载int.Equals(object),因为参数不是隐式转换为sbyte.
等于它们是对称的,但是你的呼叫代码不是.如果使用i.Equals((object)j)抑制隐式转换,它将返回false,表明Equals确实是对称的.
c# – 为什么不应该使用反射来实现Equals和GetHashCode？
public override int GetHashCode()
{
int hash = 17;
foreach (PropertyInfo p in GetType().GetProperties())
{
hash = hash * 23 + p.GetValue(this,null).GetHashCode();
}
return hash;
}
public override bool Equals(object obj)
{
foreach (PropertyInfo p in GetType().GetProperties())
{
if (p.GetValue(obj,null) != p.GetValue(this,null))
return false;
}
return true;
}
除了速度考虑,为什么我不应该这样实现？
解决方法
比较字段而不是属性更可靠
>你的代码做出错误的假设,如果它们是相同的引用(你使用==),两个对象被认为是相等的.这不是这样,因为许多类型通过.Equals实现值相等.两个不同的参考文献被认为是相等的,并且会击败你的测试是非常有可能和合法的.
>如果这种平等的形式以广泛的方式通过代码库使用,那么当对象图形具有循环时,它将很容易导致无限递归.
> GetHashCode方法忽略一个属性可以为null
下面是一个类型的具体示例,这将在应用程序中引起无限递归
class C1 {
public object Prop1 { get; set; }
};
var local = new C1();
local.Prop1 = local;
var x = local.GetHashCode(); // Infinite recursion
c# – 如何使用覆盖逻辑Equals()实现GetHashCode()的覆盖
1.我不知道如何使用Equals(Object)逻辑实现GetHashCode().
2.有一些派生类,如果我覆盖基类(Param)的GetHashCode()和Equals(Object),是否仍然需要为子项覆盖它？
class Param
{
...
public Int16 id { get; set; }
public String name { get; set; }
...
public override bool Equals(object obj)
{
if ( obj is Param){
Param p = (Param)(obj);
if (id > 0 && p.id > 0)
return (id == p.id);
else if (name != String.Empty && p.name != String.Empty)
return (name.equals(p.name));
else
return object.ReferenceEquals(this,obj);
}
return false;
}
}
class Item
{
public int it_code { get; set; }
public Dictionary<String,Param> paramAr { get; set; }
...
public override bool Equals(Object obj)
{
Item im = new Item();
if (obj is Item)
im = (Item)obj;
else
return false;
if (this.it_code != String.Empty && im.it_code != String.Empty)
if (this.it_code.Equals(im.it_code))
return true;
bool reParams = true;
foreach ( keyvaluePair<String,Param> kvp in paramAr ){
if (kvp.Value != im.paramAr[kvp.Key]) {
reParams = false;
break;
}
}
return reParams;
}
}
class Order
{
public String or_code { get; set; }
public List <Item> items { get; set; }
...
public override bool Equals( Object obj ){
Order o = new Order();
if (obj is Order)
o = (Order)obj;
else
return false;
if (this.or_code != String.Empty && o.or_code != String.Empty)
if (this.or_code.Equals(o.or_code))
return true;
bool flag = true;
foreach( Item i in items){
if (!o.items.Contains(i)) {
flag = false;
break;
}
}
return flag;
}
}
编辑：
我收到这个警告：
Warning : ‘Item’ overrides Object.Equals(object o) but does not
override Object.GetHashCode()
解决方法
见http://msdn.microsoft.com/en-us/library/system.object.gethashcode.aspx – 特别是“对实施者的说明”
因此,如果您以Equals的Item实现为例,您将考虑id和name的值来影响相等性.因此,这两者必须有助于GetHashCode实现.
您可以如何为Item实现GetHashCode的示例将如下所示(请注意,您可能需要使其具有对可空名称字段的弹性)：
public override GetHashCode()
{
return id.GetHashCode() ^ name.GetHashCode();
}
请参阅Eric Lippert关于GetHashCode指南的博客文章 – http://ericlippert.com/2011/02/28/guidelines-and-rules-for-gethashcode/
至于你是否需要在子类中重新实现GetHashCode – 是的,如果你也重写等于 – 按照第一个(和主要的)点 – 两者的实现必须是一致的 – 如果两个项被认为等于等于那么它们必须从GetHashCode返回相同的值.
边注：
作为代码的性能改进(避免多次转换)：
if ( obj is Param){
Param p = (Param)(obj);
Param p = obj as Param;
if (p != null) ...
Effective-Java读书笔记09 Always override hashCode when you override equals 重写equals方法时一定要重写hashCode方法
"重写equals方法时为啥要重写hashCode方法?"这个可能是面试出场率最高的问题了, 没有之一. 不重写hashCode方法会导致所有使用hash值的集合类处理异常, 比如HashMap和HashSet. 原理很好理解, 以HashMap为例, 在get和put时, 会认为equals和hash值都相等的元素才是同一个元素.
Object中提供的hashCode方法是一个native方法, 它的底层实现逻辑是将对象内存地址转换为整数返回, 所以可以保证同一个对象的hashCode返回是一致的.
下面java规范中关于hashCode的部分
- 一致性, 对于一个对象, 当equals方法使用的比较属性没有变化时, hashCode多次执行结果是一样的.
- 如果两个对象的equals方法判断相等, 那么这两个对象的hashCode方法返回值也必须相等.
- equals判断不相等的两个对象, 不要求这两个对象的hashCode返回结果一定不一样, 但是如果不一样的话会提供系统性能.
- 定义一个整数result = 17.
- 将每一个会影响equals方法的属性转换为一个整数.
- 将每一个属性的整数结果通过下面的公式累加到result
result = result * 31 + c // c是属性的整数值.
在第二步中作者给出了每一个类型转换为整数的方式, 如下(f表示属性):
- boolean: 返回 f ? 1 : 0;
- byte, char, short, int: 返回(int) f;
- long: (int)(f ^ (f >>> 32));
- float: Float.floatToIntBits(f);
- double: Double.doubleToLongBits(f), 得到long结果, 再按照long类型处理.
- 引用类型: 使用其hashCode方法. 对于null返回0.
- 数组类型: 对其中每一个元素按照上述规则求值, 或者使用Arrays.hashCode().
关于上面的规则, 有两个问题
- 这么多转换规则, 我不可能记住.
- 上面17, 31为啥是17, 31?
问题一: 刚看到这里的时候就懵了, 这么多都要记? 看到第四条Float.floatToIntBits(f)想到一点, 不如看看它们的包装类型是怎么做的. 果然, 这些数字类型的包装类型会实现一个静态的hashCode方法, 入参是实际值, 实现内容跟作者说的基本一样(jdk 1.8), 除了boolean, 作者说的是1和0, jdk中是1231和1237. 所以对于数字类型, 我们不需要再记忆这些, 直接使用对应的静态方法即可. 比如double类型, 我们可以直接返回Double.hashCode(f), Double的hashCode如下:
@Override
public int hashCode() {
return Double.hashCode(value);
}
public static int hashCode(double value) {
long bits = doubleToLongBits(value);
return (int)(bits ^ (bits >>> 32));
}
问题二: 回忆下文章开始的hashCode规范, 三条规则概括起来是两条内容: 一是hashCode返回要正确, 不会影响业务; 二是好的hashCode会系统提高性能.
问题二中的17和31就要从系统性能说起. 那么hashCode的值为什么会影响系统性能? 举个例子, 如果hashCode方法对于任何对象都返回1会怎么样? 首先这样是满足规范要求, 不影响业务判断. 但是当我们把这样的对象插入到hash表中时会发现, 因为所有的对象的hash值一样, 所以都插入到了同一个槽中, 也就是说hash表退化成了链表结构, 查询性能从O(1)恶化为O(n).
为了让hash表更平均需要hashCode返回值更合理, "更合理"意思就是"更少的hash冲突", 所以hashCode方法多使用17和31这样的质数来参加运算, Boolean的hashCode方法中的1231和1237也是同样道理.
那为什么质数的hash冲突更少? 这个应该有严格的数学推论, 简单来说, hash槽是通过 hashCode % n (n为hash表大小) 确定的, 如果值为0表示可以被n整除, 那么所有可以被n整除的hashCode都会被分配到同一个槽中, 所以如果是质数的话就不会出现整除情况(HashMap大小是2的n次方), 所以冲突的可能性更小(以上没有数学证明, 只是感觉~).
我们今天的关于C#正确实现Equals方法,如何实现GetHashCode方法的分享已经告一段落，感谢您的关注，如果您想了解更多关于c# – Equalsistency in Equals和GetHashCode方法、c# – 为什么不应该使用反射来实现Equals和GetHashCode？、c# – 如何使用覆盖逻辑Equals()实现GetHashCode()的覆盖、Effective-Java读书笔记09 Always override hashCode when you override equals 重写equals方法时一定要重写hashCode方法的相关信息，请在本站查询。
本文标签：
