为此结构实现 GetHashCode 的正确方法

Question

我想使用一个日期范围（从一个日期到另一个日期）作为字典的键，所以我编写了自己的结构：

   struct DateRange
   {
      public DateTime Start;
      public DateTime End;

      public DateRange(DateTime start, DateTime end)
      {
         Start = start.Date;
         End = end.Date;
      }

      public override int GetHashCode()
      {
         // ???
      }
   }

实现 GetHashCode 的最佳方法是什么，这样不同范围的两个对象都不会生成相同的哈希？我希望哈希冲突尽可能地降低，尽管我理解 Dictionary 仍会检查我还将实现的相等运算符，但不想过多地污染示例代码。谢谢！

Answer 1

您可以使用有效 Java 中的方法，如 Jon Skeet 显示的 here。对于您的特定类型：

public override int GetHashCode()
{
    unchecked // Overflow is fine, just wrap
    {
        int hash = 17;
        hash = hash * 23 + Start.GetHashCode();
        hash = hash * 23 + End.GetHashCode();
        return hash;
    }
}

Answer 2

在C# 7 你可以这样做：

public override int GetHashCode() => (Start, End).GetHashCode();

ValueTuple 在.NET Framework 4.7 和.NET Core 中提供，或通过NuGet 提供。

不确定它的性能如何，但如果有任何自定义代码能够击败它，我会感到惊讶。

Answer 3

我会相信微软在元组中的 GetHashCode() 实现，并使用这样的东西，而不需要任何愚蠢的魔法：

public override int GetHashCode()
{
    Tuple.Create(x, y).GetHashCode();
}

Answer 4

由于 DateTime.GetHashCode 内部是基于 Ticks 的，那么这个呢：

    public override int GetHashCode()
    {
        return unchecked((int)(Start.Ticks ^ End.Ticks));
    }

或者，由于您似乎对日期部分（年、月、日）感兴趣，而不是全部，因此此实现使用两个日期之间的天数，并且应该几乎没有冲突：

        public override int GetHashCode()
        {
            return unchecked((int)Start.Date.Year * 366 + Start.Date.DayOfYear + (End.Date - Start.Date).Days);
        }

Answer 5

不是为了让死者复活，但我来这里是为了寻找一些东西，对于更新的 C# 版本，你可以这样做

public override int GetHashCode()
{
    return HashCode.Combine(Start, End);
}

目前可以在此处找到源：https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/shared/System/HashCode.cs

在我的初步测试中（使用 Jon Skeets 微基准测试框架），在性能方面，它似乎与公认的答案非常相似。

Answer 6

就像它可能对将来使用 Visual Studio Pro 的人有所帮助（不确定这是否也存在于社区版中）

• 选择所需的属性（在您的情况下为全部）
• 按重构（CTRL + . 或右键单击“快速操作和重构”）
• 现在您可以选择实现 Equals 或 GetHashcode（并且可能总是采用最知名的 MS 方法来实现）

Answer 7

类似这样的东西:) 使用不同的质数:)

public override int GetHashCode()
{
    unchecked  
    {
        int hash = 23;
        // Suitable nullity checks etc, of course :)
        hash = hash * 31 + Start.GetHashCode();
        hash = hash * 31 + End.GetHashCode();
        return hash;
    }
}

这不是最快的实现，但它产生了一个很好的哈希码。 Joshua bloch 指出，你也计算性能，^ 通常更快。如果我错了，请纠正我。

请参阅 Jon Skeets impl 了解 c#：

Answer 8

结合 Jon Skeet 的 answer 和对 question 的评论（所以请不要对此投票，只是合并）：

struct DateRange
{
    private readonly DateTime start;

    private readonly DateTime end;

    public DateRange(DateTime start, DateTime end)
    {
        this.start = start.Date;
        this.end = end.Date;
    }

    public DateTime Start
    {
        get
        {
            return this.start;
        }
    }

    public DateTime End
    {
        get
        {
            return this.end;
        }
    }

    public static bool operator ==(DateRange dateRange1, DateRange dateRange2)
    {
        return dateRange1.Equals(dateRange2);
    }

    public static bool operator !=(DateRange dateRange1, DateRange dateRange2)
    {
        return !dateRange1.Equals(dateRange2);
    }

    public override int GetHashCode()
    {
        // Overflow is fine, just wrap
        unchecked
        {
            var hash = 17;

            // Suitable nullity checks etc, of course :)
            hash = (23 * hash) + this.start.GetHashCode();
            hash = (23 * hash) + this.end.GetHashCode();
            return hash;
        }
    }

    public override bool Equals(object obj)
    {
        return (obj is DateRange)
            && this.start.Equals(((DateRange)obj).Start)
            && this.end.Equals(((DateRange)obj).End);
    }
}