custom == for Dictionary扩展认为它们'为空

我有一个(enum: int) AccessOptions，它用于填充Dictionary，以反映索引用户主体名称列表的简单访问属性。

我需要支持单元测试——特别是

    Assert.AreEqual
    <Dictionary<string, AccessOptions>, 
    Dictionary<string, AccessOptions>)

…这很混乱，并调用Dictionary泛型的相等操作符，该操作符实际上只检查参考值——我需要的是确定两个不同的引用对象包含相同的键值，并且这些键的关联值在每种情况下都是匹配的。

因此，我编写了自己的相等操作符，并创建了一个扩展Dictionary的类，以避免在我的项目中搞砸Dictionary对象。在Visual Studio 2016中调试单元测试Assert的上下文中执行此方法时。AreEqual调用，有几件事偏离了方向，我将在下面用注释标记它们。

        public class SecretAccessRuleSet : Dictionary<string, AccessOptions>
{
    public SecretAccessRuleSet() {}
    public SecretAccessRuleSet(int size) : base (size) {}
    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        return obj.GetType() == GetType() && Equals((SecretAccessRuleSet) obj);
    }
    public static bool operator == (SecretAccessRuleSet a, SecretAccessRuleSet b)
    {
        if (ReferenceEquals(a, b))  
        { 
            return true; 
        }
        /* When the below statement executes in debug, I can watch 
         * execution flow from the equality test against (object)a,
         * straight to "return false" -- but execution does not actually
         * return, but appears to jump directly to the foreach statement
         * two blocks down.  It might be important, or just a bug.  
         */
        if (((object)a == null) || ((object)b == null))
        {
            return false;
        }
        if (a.Count != b.Count)
        {
            return false;
        }
        /* Then when we get here, the visualizer highlights a; I advance 
         * one line and it highlights "in", which I assume is wherein an 
         * enumerator is initialized; I advance again and we jump to the 
         * end of the method!  Literally to the end curly brace.  
         */
        foreach (var entry in a)
        {
            AccessOptions bOpt;
            if (!b.TryGetValue(entry.Key, out bOpt)
                || bOpt != entry.Value)
            {
                return false;
            }
        }
        // If we get here, they're equal
        return true;
    }
    public bool Equals(SecretAccessRuleSet other)
    {
        return this == other;
    }
    public static bool operator !=(SecretAccessRuleSet a, SecretAccessRuleSet b)
    {
        return !(a == b);
    }
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}

测试结果表明Assert。AreEqual(a, b)调用返回false，但我不太相信两个集合的内容都被求值了，我不明白为什么。

我可能会删除所有这些，并创建一个单独的方法来测试这些，而不重写操作符，但是——这里出了什么问题?

(感谢大家的宝贵时间)

Update:为了指定我忘记的东西，两个集合都是预期的类型，非null，并且都包含2个条目——实际上是相同的2个条目;我期望相等运算符在测试中返回true。

Update 2:我分隔了null检查;"(object) a == null"的计算结果为false，并继续，但"(object) b == null"的计算结果似乎为true，并将执行发送到"返回false"——但是，同样的两个问题，执行实际上并不返回，而是试图枚举第一个…b也不是零。是否存在b是一个有效对象但(object) b中的强制转换操作可能失败的原因?

public override bool Equals(object obj)
{
    if (ReferenceEquals(this, obj)) return true;
    var other = obj as SecretAccessRuleSet;
    if (other == null) return false;
    if (Count != other.Count) return false;
    if (Keys.Except(other.Keys).Any()) return false;
    return Keys.All(k => string.Equals(this[k], other[k]));
}