Does Dictionary.Equals() have an implementation?

I have a Dictionary which I am comparing to another Dictionary (variables typed as IDictionary). Doing d1.Equals(d2) yields false. Writing my own code below yields true. Both are System.Collections.Generic.Dictionary. Am I missing something or does Dictionary not have an Equals implementation t开发者_运维技巧hat compares keys/values?

private static bool DictEquals<K, V>(IDictionary<K, V> d1, IDictionary<K, V> d2)
{
    if (d1.Count != d2.Count)
        return false;

    foreach (KeyValuePair<K, V> pair in d1)
    {
        if (!d2.ContainsKey(pair.Key))
            return false;

        if (!Equals(d2[pair.Key], pair.Value))
            return false;
    }

    return true;
}

Dictionary.Equals() uses the default Equals from Object, checking if the two objects are the same reference, as does all the other default collections. You're free to create your own subclass with value semantics, though that usually includes things being immutable as well.

Probably the Equals method of the Dictionary class simply resorts to the default implementation inherited from Object, that is, it just compares the Dictionary object reference passed with its own reference. See here: Object.Equals reference

Assuming that two dictionaries, one being a SortedList<TKey, TValue> and one a Dictionary<TKey, TValue>, are compared for equality, should it really return true if the items are the same? That would be pretty bad, since they have different characteristics and features (the SortedList<,> for instance allows retrieval via index).

Also, equality and hash code are logically tied together. The hash code should be immutable, otherwise all hash based algorithms will not work. You cannot guarantee this when you're using the contents to check for equality. Therefore, the default implementation (checking if they are the same instance) is quite sane. You're free to create your own content equality comparison though.

Others have mentioned that it is using the Object.Equals implementation, you can use the following to override it:

public class EqualsDictionary<T, T> : Dictionary<T, T>
{
    public override bool Equals(object obj)
    {
        //Place your comparison implementation here
    }
}

References in .NET may be used to encapsulate an object's identity, mutable aspects of its state, both, or neither, in addition to encapsulating immutable aspects of an object's state. In general, absent a particular reason to assume otherwise, .NET assumes that references to mutable objects are used for the purpose of encapsulating identity. It further assumes that in cases where code is comparing references without knowing what they represent, it is better to err on the side of reporting things unequal. As such, two references to mutable objects are generally considered equivalent if and only if they identify the same object, and mutable types are thus discouraged from overriding Equals to indicate anything else. Instead, code which uses references to encapsulate mutable state should use some means other than Object.Equals() to compare them.