比较SortedDictionary <string, List<foo> &gt; C＃

Question

I asked similar question here , I am wondering how you can achieve same result with LINQ

PREVIOUS QUESTION

Compare Dictionary

Rules

Get values from dic2 where key match but values does not match or key is missing in dic2. Don't need to iterate through dic2 for missing/different values in dic1.

LINQ CODE

can result and missinkeu can combin strong text e in one?

private void Compare(SortedDictionary<string, List<foo>> dic1, SortedDictionary<string, List<foo>> dic2)
 {

            var result=   from c in dic1
                          where dic2.ContainsKey((c.Key) && !dic2[c.key]Equals(c.Value)
                          select p.Value;


            var missingkey =from c in dic1
                          where !dic2.ContainsKey((c.Key) 
                          select p.Value;
 } 

Answer 1

It would be better to write this as a loop instead. Here's how I would implement it:

static void Compare(SortedDictionary<string, List<foo>> dic1, SortedDictionary<string, List<foo>> dic2)
{
    var result = new List<List<foo>>();
    var missingkey = new List<List<foo>>();

    foreach (var kvp in dic1)
    {
        var value = default(List<foo>);
        if (dic2.TryGetValue(kvp.Key, out value))
        {
            if (kvp.Value.SequenceEqual(value))
                result.Add(value);
        }
        else
        {
            missingkey.Add(kvp.Value);
        }
    }
}

If you insist on using LINQ to do this, here's one way to do it:

static void Compare(SortedDictionary<string, List<foo>> dic1, SortedDictionary<string, List<foo>> dic2)
{
    const string isIgnored = null, isResult = "result", isMissingkey = "missingkey";
    var combined = (from kvp in dic1
                    group kvp.Value by (dic2.ContainsKey(kvp.Key)
                                            ? kvp.Value.SequenceEqual(dic2[kvp.Key])
                                                  ? isResult
                                                  : isIgnored
                                            : isMissingkey) into g
                    where g.Key != isIgnored
                    select g)
                   .ToDictionary(g => g.Key, g => g.ToList());

    // result in combined["result"]
    // missingkey in combined["missingkey"]
}

Answer 2

Do you just mean:

        var result = from pair in dic1
                     where !dic2.ContainsKey(pair.Key)
                        || !dic2[pair.Key].Equals(pair.Value)
                     select pair.Value;

when the key is there the second match is tested. Note however, that this will only (as written) do a reference test on the lists - it won't compare individual elements. It is hard to tell if that is what you mean since the code example in the linked post is... "unclear" (in that it attempts to add foo as value for List<foo> ).

If you need to test the individual values:

        var result = from pair in dic1
                     where !dic2.ContainsKey(pair.Key)
                     || !dic2[pair.Key].SequenceEqual(pair.Value)
                     select pair.Value;

(which assumes a sensible Equals implementation on foo .