finding difference between two dictionaries

Question

Is there a LINQ method to find difference between two generic dictionaries?
Same as in this question, but with generic dictionaries.

Answer 1

var diff = dicOne.Except(dicTwo).Concat(dicTwo.Except(dicOne));

Answer 2

If performance is important, you might want to use the hash lookup of the Dictionary class and get a speed improvement. I took a test scenario of a dictionary with 1 million entries, deep-copied it and made 10 edits (5 entries removed, 5 added) to the copy. [I had a task to do that involved looking for changes in data, and then pushing only the changes through to another function.]

With LINQ (see Magnus' answer) time elapsed according to Stopwatch was 3600ms approx. With simple comparison using Dictionary.Contains(), time elapsed was 600ms approx. Environment was Visual Studio 2017 Community in Debug mode for a ConsoleApp test harness, on same machine.

Your mileage may vary, and you might have a modest number of lines, so it might not matter, but for larger dictionaries it pays to use the lookup functionality of the Dictionary class.

In the example below dicA and dicB are the two similar dictionary objects that you want to difference. dicAdd is the dictionary of items that A has, but which are missing from B. dicDel is the reverse, items that B contains, but A does not. Try using with some very simple test dictionaries where you know what to expect, and it should become clear how to use.

    public static void DiffDictionaries<T, U>(
        Dictionary<T, U> dicA,
        Dictionary<T, U> dicB,
        Dictionary<T, U> dicAdd,
        Dictionary<T, U> dicDel)
    {
        // dicDel has entries that are in A, but not in B, 
        // ie they were deleted when moving from A to B
        diffDicSub<T, U>(dicA, dicB, dicDel);

        // dicAdd has entries that are in B, but not in A,
        // ie they were added when moving from A to B
        diffDicSub<T, U>(dicB, dicA, dicAdd);
    }

    private static void diffDicSub<T, U>(
        Dictionary<T, U> dicA,
        Dictionary<T, U> dicB,
        Dictionary<T, U> dicAExceptB)
    {
        // Walk A, and if any of the entries are not
        // in B, add them to the result dictionary.

        foreach (KeyValuePair<T, U> kvp in dicA)
        {
            if (!dicB.Contains(kvp))
            {
                dicAExceptB[kvp.Key] = kvp.Value;
            }
        }
    }