Dictionary.ContainsKey 返回 False，但想要 True

Question

namespace Dic
{
public class Key
{
    string name;
    public Key(string n) { name = n; }
}

class Program
{
    static string Test()
    {
        Key a = new Key("A");
        Key b = new Key("A");
        System.Collections.Generic.Dictionary<Key, int> d = new System.Collections.Generic.Dictionary<Key, int>();
        d.Add(a, 1);
        return d.ContainsKey(b).ToString();
    }

    static void Main(string[] args)
    {
        System.Console.WriteLine(Test());
    }
}
}

我应该改变什么才能实现？

Answer 1

你想要真的 - 但 a 和 b 是不同的对象。

您需要在类 Key 上覆盖 GetHashCode 和 Equals

public class Key
{
    string name;
    public Key(string n) { name = n; }

    public override int GetHashCode()
    {
        if (name == null) return 0;
        return name.GetHashCode();
    }

    public override bool Equals(object obj)
    {
        Key other = obj as key;
        return other != null && other.name == this.name;
    }
}

Answer 2

如果您覆盖 Key.GetHashCode 和 Key.Equals 可能会有所帮助。

在Key:

public override bool Equals(object obj)
{
    var k = obj as Key;
    if (k != null)
    {
        return this.name == k.name;
    }
    return base.Equals(obj);
}

public override int GetHashCode()
{
    return this.name.GetHashCode();
}

Answer 3

如果您没有能力像其他人提到的那样覆盖相等运算符/Equals/GetHashCode（例如，您不控制对象的源代码），您可以在构造函数中提供IEqualityComparer<Key> 实现执行相等性检查的字典。

class KeyComparer : IEqualityComparer<Key>
{
    public bool Equals(Key x, Key y)
    {
        return x.Name == y.Name;
    }

    public int GetHashCode(Key obj)
    {
        return obj.Name.GetHashCode();
    }
}

就目前而言，您的 Key 是一个引用对象，因此除非您以其他方式告诉世界（或字典），否则仅在引用上确定相等性。

Answer 4

重写类的 GetHashCode 和 Equals 方法以使其在字典中正常工作不是一个很好的方法。字典的行为方式应该是字典的实现细节，而不是用作键的任何类。当您想在具有不同行为的不同字典中使用该类时，您会遇到麻烦。或者，如果您无权访问课程源代码。

更好的鼠标陷阱是为字典提供自己的比较器。例如：

using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] args) {
        var d = new Dictionary<Key, int>(new MyComparer());
        d.Add(new Key("A"), 1);
        Console.WriteLine(d.ContainsKey(new Key("a")));
        Console.ReadLine();
    }
    private class MyComparer : IEqualityComparer<Key> {
        public bool Equals(Key x, Key y) {
            return string.Compare(x.Name, y.Name, true) == 0;
        }
        public int GetHashCode(Key obj) {
            return obj.Name.ToUpper().GetHashCode();
        }
    }
    public class Key {
        public string Name { get; set; }
        public Key(string name) { Name = name; }
    }
}

Answer 5

为了使用您自己的类作为字典键，您应该覆盖 GetHashCode 和 Equals。否则它将使用内存地址来检查是否相等。

公共类密钥 { 字符串名称； 公钥（字符串 n）{ 名称 = n; } 公共覆盖 int GetHashCode() { 返回名称.GetHashCode(); } 公共覆盖布尔等于（对象obj） { var other = obj 作为键； 如果（其他 == 空） 返回假； 返回名称 == 其他名称； } }

Answer 6

您需要覆盖 Key 类的 Equals 和 GetHashCode 方法。

Answer 7

你的问题是

new Key("A").Equals(new Key("A"))==false.

和

new Key("A").GetHashCode()!=new Key("A").GetHashCode()

修复它，我认为它应该可以工作。要修复它，请覆盖 Equals 方法并检查名称值是否相同。如果要覆盖 Equals，还应该覆盖 GetHashCode。

Answer 8

1.覆盖等于、获取哈希码和“==”运算符。

Key 类必须覆盖Equals，以便字典检测它们是否相同。默认实现仅检查引用。

这里：

        public bool Equals(Key other)
        {
            return this == other;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is Key))
            {
                return false;
            }

            return this.Equals((Key)obj);
        }

        public static bool operator ==(Key k1, Key k2)
        {
            if (object.ReferenceEquals(k1, k2))
            {
                return true;
            }

            if ((object)k1 == null || (object)k2 == null)
            {
                return false;
            }

            return k1.name == k2.name;
        }

        public static bool operator !=(Key k1, Key k2)
        {
            if (object.ReferenceEquals(k1, k2))
            {
                return false;
            }

            if ((object)k1 == null || (object)k2 == null)
            {
                return true;
            }

            return k1.name != k2.name;
        }

        public override int GetHashCode()
        {
            return this.name == null ? 0 : this.name.GetHashCode();
        }

2。如果可能，请使用结构。

您应该为这样的不可变数据类型使用结构，因为它们是按值传递的。这意味着您不会意外地将两个不同的值混入同一个键中。

Answer 9

它们在内部具有相同的值，但 a != b 因为它们是 2 个不同的变量。

Answer 10

您需要覆盖 Key 类的 Equals 和 GetHashCode 方法。在您的情况下，您可以根据键的名称（如果您的类更复杂，则可以根据任何其他唯一属性）进行比较。

public class Key {
    string name;
    public Key(string n) { name = n; }

    public override bool Equals(object obj) {
        Key k = obj as Key;
        if (k == null)
            return false;
        return name.Equals(k.name);
    }

    public override int GetHashCode() {
        return name.GetHashCode();
    }
}

Answer 11

然后你需要覆盖 Key 类的 GetHashCode 和 Equals。

如果不这样做，您将获得两者的默认实现。这导致 a 和 b 的哈希码很可能不相同（我不知道默认实现是什么样的），并且 a 绝对不等于 b （默认 Equals() 实现检查引用相等)。

在您的情况下，假设“名称”不是空值，它可以实现为

   public class Key
   {
        string name;
        public override int GetHashCode()
        {
             return name.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
              return false;
            }

            Key objAsKey = obj as Key;
            if (objAsKey == null)
            {
              return false;
            }

            return this.name.Equals(objAsKey.Name);
        }
    }

这是否是一个令人满意的哈希是另一回事，但它显示了原理。

Answer 12

在这种情况下，ContainsKey 将 Key 作为对象进行比较，并检查对象本身是否相同——它们不是。您需要实现 IComparable 或覆盖 Key.Equals 或类似的东西以使其执行您想要的操作。