Compare items in two lists

Question

I have a method which compares two lists of strings. If the strings, and only the strings, from listA appear in listB, return true. Else return false.

internal bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds)
    {
        bool result = true;

        if (Ids.Count == XmlIds.Count)
        {
            foreach (var hwId in Ids)
            {
                if(!XmlIds.Contains(hwId))
                {
                    result = false;
                    break;
                }
            }
        }
        else
        {
            result = false;
        }

        return result;
    }

My initial unit test is passing (no edge cases etc. yet), but I was wondering if there is a more compact, but still readable, way to do it.

Answer 1

So let me get this straight, you are trying to determine if list A is a subset of list B?

internal bool DoIdsMatchThoseFromXml(List<string> ids, List<string> xmlIds)
{
    return !ids.Except(xmlIds).Any(); // A - B = {}
}

Or are you trying to see if list A is set equal to list B?

internal bool DoIdsMatchThoseFromXml(List<string> ids, List<string> xmlIds)
{
    return ids.Count == xmlIds.Count // assumes unique values in each list
        && new HashSet<string>(ids).SetEquals(xmlIds);
}

I would avoid performing linear searches through this as you'd be looking at O(n*m) performance when you could be doing O(n+m). Use set operations if you can. Use HashSet<string> if possible too.

Answer 2

If you can use LINQ, I think you can do

internal bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds)
{
    return 
        Ids.Count == XmlIds.Count &&
        Ids.All(XmlIds.Contains) &&
        XmlIds.All(Ids.Contains);
}

to achieve the same result.

Answer 3

This uses no LINQ, just methods defined on List<T>:

    internal static bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds)
    {
        return Ids.TrueForAll(XmlIds.Contains) && XmlIds.TrueForAll(Ids.Contains);
    }

Answer 4

The solutions proposed by Jeff and w0lf are very fine, but have you considered simply rearranging your code a little bit? Because even though the following does O(M*N), your question was about readability, not performance, and I think that people unfamiliar with linq will find this more graspable:

internal bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds)
{
    if (Ids.Count != XmlIds.Count)
        return false;
    foreach (var hwId in Ids)
        if(!XmlIds.Contains(hwId))
            return false;
    return true;
}

Answer 5

This is more compact, but also performs better:

internal bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds) {
  if (Ids.Count != XmlIds.Count) return false;
  HashSet<string> xmlIds = new HashSet<string>(XmlIds);
  return Ids.All(id => xmlIds.Contains(id));
}

This is close to O(n), compared to the original O(n*n).

Answer 6

If you sort the two lists and then return the SequenceEqual method you can do it all in three lines of code. SequenceEqual returns whether or not two Lists have the same items in the same order (hence the sorting before the comparing).

    internal bool DoIdsMatchThoseFromXml(List<string> Ids, List<string> XmlIds)
    {
        Ids.Sort();
        XmlIds.Sort();

        return Ids.SequenceEqual(XmlIds);
    }