征求意见：字典键的快速散列基类

Question

在我的一个应用程序中，我必须使用许多带有自定义对象作为键的字典。为了提高查找的性能，我实现了一个覆盖 GetHashCode 的基类。 它似乎可以工作，但不知何故我仍然对它有一种不好的感觉，所以我决定发布我的代码，如果有任何提示或意见，我将不胜感激。 （天哪，我忘记了代码：D）

abstract class FastHashed
{
    private static Dictionary<Type,ulong> _instanceCounters = new Dictionary<Type,ulong>();

    private int hash;

    protected FastHashed()
    {
        Type instanceType = this.GetType();
        if(! _instanceCounters.ContainsKey(instanceType)) _instanceCounters.Add(instanceType,0);  
        this.hash = ((instanceType.ToString())+(_instanceCounters[instanceType]++.ToString())).GetHashCode();
    }

    public override int  GetHashCode()
    {
         return hash;
    }
}

编辑：如果你不需要，不要乱用散列。这个“解决方案”比默认的 GetHashCode() 更慢，更不可靠。

编辑： 我使用 Equatec 分析器和一个简单的控制台应用程序进行了一些性能测试。

类程序 { 静态只读 int 周期 = 50000； 静态字典 objectsDict = new Dictionary(); static Dictionary foosDict = new Dictionary();

    static void Main(string[] args)
    {

        foo[] foos = new foo[cycles];
        object[] objects = new object[cycles];


        for (int i = 0; i < cycles; i++)
        {
            foos[i] = new foo();
            objects[i] = new object();
            foosDict.Add(foos[i], i);
            objectsDict.Add(objects[i], i);
        }

        ObjectHash(objects);
        FooHash(foos);

    }

    static void ObjectHash(Object[] objects)
    {
        int value; 
        for (int i = 0; i < cycles; i++)
        {
            value = objectsDict[objects[i]];
        }

    }
    static void FooHash(foo[] foos)
    {
        int value;
        for (int i = 0; i < cycles; i++)
        {
            value = foosDict[foos[i]];
        }
    }

    class foo
    {
        private readonly int _hash;
        public foo()
        {
            _hash = this.GetHashCode();
        }
        public override int GetHashCode()
        {
            return _hash;
        }
    }
}

结果： - FooHash 26 774 毫秒 - 对象哈希 7 毫秒

显然默认的 GetHashCode 是最好的选择。

Answer 1

1. 这不是线程安全的。
2. 如果您只关心引用相等性，为什么要为不同类型设置不同的计数器？

如果你想要的只是防止哈希被计算多次，为什么不这样做（或者如果字典只包含某种类型的对象，则使用泛型的变体）：

  public class ObjectWithCachedHashCode : IEquatable<ObjectWithCachedHashCode>
    {
        private int _cachedHashCode;

        public object Object { get; private set; }

        public ObjectWithCachedHashCode(object obj)
        {
            Object = obj;
            _cachedHashCode = obj.GetHashCode();
        }

        public override int GetHashCode()
        {
            return _cachedHashCode;
        }

        public bool Equals(ObjectWithCachedHashCode other)
        {
            return other!=null && Object.Equals(other.Object);
        }

        public override bool Equals(object other)
        {
            return Equals(other as ObjectWithCachedHashCode);
        }


    }

编辑：使类与字典兼容

Answer 2

您可以将哈希变量标记为readonly。

但老实说，在具有单一继承的 C# 中，“浪费”继承来实现这种特定行为并不总是明智的。假设您突然想要从“做”某事的基类继承。将类继承保存到建模目的，而不是实现细节。

Answer 3

据我所知，这在功能上等同于 object.GetHashCode() 默认实现，除了速度较慢且非线程安全之外。是什么让“Fast Hash”快速？