Compare two dictionaries for equality

With C# i want to compare two dictionaries with

keys as string and
value as a list of ints.

I assume two dictionaries to be equal when

they both have the same keys
and for each key each value in a list of integers is the same (both not necessarily in the same order).

I use both the answers from this and this related question, but both fail my test suite for the test functions DoesOrderKeysMatter and DoesOrderValuesMatter.

My test suite:

public static List<int> GetList(int x, int y)
{
   List<int> list = new List<int>();
             list.Add(x);
             list.Add(y);
   return list;
}

public static Dictionary<string, List<int>> GetDict1()
{
   Dictionary<string, List<int>> dict1 = new Dictionary<string, List<int>>();
   dict1.Add("a", GetList(1,2));
   dict1.Add("b", GetList(3,4));
   return dict1;
}

public static Dictionary<string, List<int>> GetDict2()
{
   Dictionary<string, List<int>> dict2 = new Dictionary<string, List<int>>();
   dict2.Add("b", GetList(3,4));
   dict2.Add("a", GetList(1,2));
   return dict2;
}

The test class

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Linq;
    
    
namespace UnitTestProject1
{
  [TestClass]
  public class ProvideReportTests
  {
     [TestMethod]
     public void AreSameDictionariesEqual()
     {
        // arrange
        Dictionary<string, List<int>> dict1 = GetDict1();    
        // act
        bool dictsAreEqual = false;
        dictsAreEqual = AreDictionariesEqual(dict1, dict1);    
        // assert
        Assert.IsTrue(dictsAreEqual, "Dictionaries are not equal");    
     }
    
     [TestMethod]
     public void AreDifferentDictionariesNotEqual()
     {
        // arrange
        Dictionary<string, List<int>> dict1 = GetDict1();
        Dictionary<string, List<int>> dict2 = new Dictionary<string, List<int>>();    
        // act
        bool dictsAreEqual = true;
        dictsAreEqual = AreDictionariesEqual(dict1, dict2);    
        // assert
        Assert.IsFalse(dictsAreEqual, "Dictionaries are equal");    
     }
    
     [TestMethod]
     public void DoesOrderKeysMatter()
     {
        // arrange
        Dictionary<string, List<int>> dict1 = GetDict1();
        Dictionary<string, List<int>> dict2 = GetDict2();    
        // act
        bool dictsAreEqual = false;
        dictsAreEqual = AreDictionariesEqual(dict1, dict2);    
        // assert
        Assert.IsTrue(dictsAreEqual, "Dictionaries are not equal");    
    }
    
    [TestMethod]
    public void DoesOrderValuesMatter()
    {
        // arrange
        Dictionary<string, List<int>> dict1 = GetDict1();    
        Dictionary<string, List<int>> dict2 = new Dictionary<string, List<int>>();
        dict2.Add("a", GetList(2,1));
        dict2.Add("b", GetList(3,4));    
        // act
        bool dictsAreEqual = false;
        dictsAreEqual = AreDictionariesEqual(dict1, dict2);    
        // assert
        Assert.IsTrue(dictsAreEqual, "Dictionaries are not equal");    
    }
    
    
     private bool AreDictionariesEqual(Dictionary<string, List<int>> dict1, Dictionary<string, List<int>> dict2)
     {
          return dict1.Keys.Count == dict2.Keys.Count &&
                 dict1.Keys.All(k => dict2.ContainsKey(k) && 
                 object.Equals(dict2[k], dict1[k]));
    
          // also fails:
          //    return dict1.OrderBy(kvp => kvp.Key).SequenceEqual(dict2.OrderBy(kvp => kvp.Key));
     }
  }
}

What is the correct way to compare these kind of dictionaries? Or is there an error in my (admittedly clumsily written) TestSuite?

Update

I'm trying to incorporate Servy's answer in my test suite, like below, but I get some errors (underlined with a red wiggly line in Visual Studio):

SetEquals in the `Equals method says: "does not contain a definition for SetEquals accepting a first argument of type Generic.List.

In AreDictionariesEqualit saysDictionaryComparer<List> is a type but is used as a variable.`

namespace UnitTestProject1
{
    [TestClass]
    public class ProvideReportTests
    {
        [TestMethod]
        // ... same as above    

        private bool AreDictionariesEqual(Dictionary<string, List<int>> dict1, Dictionary<string, List<int>> dict2)
        {
            DictionaryComparer<string, List<int>>(new ListComparer<int>() dc = new DictionaryComparer<string, List<int>>(new ListComparer<int>();
            return dc.Equals(dict1, dict2);

        }

    }

    public class DictionaryComparer<TKey, TValue> :
        IEqualityComparer<Dictionary<TKey, TValue>>
    {
        private IEqualityComparer<TValue> valueComparer;
        public DictionaryComparer(IEqualityComparer<TValue> valueComparer = null)
        {
            this.valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
        }
        public bool Equals(Dictionary<TKey, TValue> x, Dictionary<TKey, TValue> y)
        {
            if (x.Count != y.Count)
                return false;
            if (x.Keys.Except(y.Keys).Any())
                return false;
            if (y.Keys.Except(x.Keys).Any())
                return false;
            foreach (var pair in x)
                if (!valueComparer.Equals(pair.Value, y[pair.Key]))
                    return false;
            return true;
        }

        public int GetHashCode(Dictionary<TKey, TValue> obj)
        {
            throw new NotImplementedException();
        }
    }

    public class ListComparer<T> : IEqualityComparer<List<T>>
    {
        private IEqualityComparer<T> valueComparer;
        public ListComparer(IEqualityComparer<T> valueComparer = null)
        {
            this.valueComparer = valueComparer ?? EqualityComparer<T>.Default;
        }

        public bool Equals(List<T> x, List<T> y)
        {
            return x.SetEquals(y, valueComparer);
        }

        public int GetHashCode(List<T> obj)
        {
            throw new NotImplementedException();
        }
    }

    public static bool SetEquals<T>(this IEnumerable<T> first, IEnumerable<T> second, IEqualityComparer<T> comparer)
        {
            return new HashSet<T>(second, comparer ?? EqualityComparer<T>.Default)
                .SetEquals(first);
        }

}

Solution

So first we need an equality comparer for dictionaries. It needs to ensure that they have matching keys and, if they do, compare the values of each key:

public class DictionaryComparer<TKey, TValue> :
    IEqualityComparer<Dictionary<TKey, TValue>>
{
    private IEqualityComparer<TValue> valueComparer;
    public DictionaryComparer(IEqualityComparer<TValue> valueComparer = null)
    {
        this.valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
    }
    public bool Equals(Dictionary<TKey, TValue> x, Dictionary<TKey, TValue> y)
    {
        if (x.Count != y.Count)
            return false;
        if (x.Keys.Except(y.Keys).Any())
            return false;
        if (y.Keys.Except(x.Keys).Any())
            return false;
        foreach (var pair in x)
            if (!valueComparer.Equals(pair.Value, y[pair.Key]))
                return false;
        return true;
    }

    public int GetHashCode(Dictionary<TKey, TValue> obj)
    {
        throw new NotImplementedException();
    }
}

but this isn't enough on its own. We need to compare the values of the dictionary using another custom comparer, not the default comparer as the default list comparer won't look at the values of the list:

public class ListComparer<T> : IEqualityComparer<List<T>>
{
    private IEqualityComparer<T> valueComparer;
    public ListComparer(IEqualityComparer<T> valueComparer = null)
    {
        this.valueComparer = valueComparer ?? EqualityComparer<T>.Default;
    }

    public bool Equals(List<T> x, List<T> y)
    {
        return x.SetEquals(y, valueComparer);
    }

    public int GetHashCode(List<T> obj)
    {
        throw new NotImplementedException();
    }
}

Which uses the following extension method:

public static bool SetEquals<T>(this IEnumerable<T> first, IEnumerable<T> second,
    IEqualityComparer<T> comparer)
{
    return new HashSet<T>(second, comparer ?? EqualityComparer<T>.Default)
        .SetEquals(first);
}

Now we can simply write:

new DictionaryComparer<string, List<int>>(new ListComparer<int>())
    .Equals(dict1, dict2);