C# - 如何使用对象中的列表覆盖 GetHashCode

Question

我正在尝试创建一个“KeySet”来修改 UIElement 行为。这个想法是创建一个特殊的函数，例如：用户按住 a 的同时单击一个元素。或者ctrl+a。

到目前为止，我的方法是，首先让我们为所有可能的修饰符创建一个容器。如果我只允许使用单个密钥，那就没问题了。我可以使用一个简单的字典，

Dictionary<Keys, Action> _specialActionList

• 如果字典为空，则使用默认操作。
• 如果有条目，请根据当前按下的键检查要使用的操作

如果我不贪心，那就是...... 当然，现在我想要更多。我想允许多个键或修饰符。因此，我创建了一个包装类，它可以用作我的字典的键。

使用更复杂的类时存在一个明显的问题。目前两个不同的实例会创建两个不同的密钥，因此他永远不会找到我的函数（请参阅代码来理解，非常明显）

现在我检查了这篇文章： GetHashCode 覆盖包含通用数组的对象 这有一点帮助。

但我的问题是，我的课程基本设计可以吗？我应该使用哈希集来存储修饰符和普通键盘键（而不是列表）。如果是这样，GetHashCode 函数会是什么样子？

我知道，需要编写大量代码（无聊的哈希函数），一些提示足以让我开始。将在这里发布试用...

到目前为止的代码，测试显然失败了...

        public class KeyModifierSet
    {
        private readonly List<Key> _keys = new List<Key>();
        private readonly List<ModifierKeys> _modifierKeys = new List<ModifierKeys>();

        private static readonly Dictionary<KeyModifierSet, Action> _testDict 
                          = new Dictionary<KeyModifierSet, Action>();

        public static void Test()
        {
            _testDict.Add(new KeyModifierSet(Key.A), () => Debug.WriteLine("nothing"));
            if (!_testDict.ContainsKey(new KeyModifierSet(Key.A))) throw new Exception("Not done yet, help :-)");
        }

        public KeyModifierSet(IEnumerable<Key> keys, IEnumerable<ModifierKeys> modifierKeys)
        {
            foreach (var key in keys)
                _keys.Add(key);

            foreach (var key in modifierKeys)
                _modifierKeys.Add(key);
        }

        public KeyModifierSet(Key key, ModifierKeys modifierKey)
        {
            _keys.Add(key);
            _modifierKeys.Add(modifierKey);
        }

        public KeyModifierSet(Key key)
        {
            _keys.Add(key);
        }
    }

Answer 1

 _testDict.Add(new KeyModifierSet(Key.A), () => Debug.WriteLine("nothing"));
 if (!_testDict.ContainsKey(new KeyModifierSet(Key.A))) throw new Exception("Not done yet, help :-)");

如果我正确理解您的代码，您希望使用 Object.Equals 和 Object.GetHashCode 方法的重写版本来测试 _testDict Dictionary 对象的相等性。据我所知，您将需要创建自己的自定义集合类型来覆盖这些方法。

Answer 2

为了回答我自己的（提出的稍微复杂的）问题，解决方案如下：

public class KeyModifierSet
{
    internal readonly HashSet<Key> Keys = new HashSet<Key>();
    internal readonly HashSet<ModifierKeys> MKeys = new HashSet<ModifierKeys>();

    public override int GetHashCode()
    {
        int hash = Keys.Count + MKeys.Count;
        foreach (var t in Keys)
        {
            hash *= 17;
            hash = hash + t.GetHashCode();
        }
        foreach (var t in MKeys)
        {
            hash *= 19;
            hash = hash + t.GetHashCode();
        }
        return hash;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as KeyModifierSet);
    }
    public bool Equals(KeyModifierSet other)
    {
        // Check for null
        if (ReferenceEquals(other, null))
            return false;

        // Check for same reference
        if (ReferenceEquals(this, other))
            return true;

        // Check for same Id and same Values
        return Keys.SetEquals(other.Keys) && MKeys.SetEquals(other.MKeys);
    }



    public KeyModifierSet(ModifierKeys mKey)
    {
        MKeys.Add(mKey);
    }
    public KeyModifierSet(Key key)
    {
        Keys.Add(key);
    }
    public KeyModifierSet(Key key, ModifierKeys mKey)
    {
        Keys.Add(key);
        MKeys.Add(mKey);
    }
    public KeyModifierSet Add(Key key)
    {
        Keys.Add(key);
        return this;
    }
    public KeyModifierSet Add(ModifierKeys key)
    {
        MKeys.Add(key);
        return this;
    }
}