Question

I have the following class:

public class DocumentCompare
{
    public string Customer;
    public string Filename;
    public string Reference;
    public DateTime? Date;

    public override bool Equals(object obj)
    {
        if (obj == null)
            return false;

        DocumentCompare doc = obj as DocumentCompare;
        if ((Object)doc == null)
            return false;

        return (doc.Customer == Customer) && (doc.Date == Date) && (doc.Filename == Filename) && (doc.Reference == Reference);
    }

    public bool Equals(DocumentCompare doc)
    {
        if ((object)doc == null)
            return false;

        return (doc.Customer == Customer) && (doc.Date == Date) && (doc.Filename == Filename) && (doc.Reference == Reference);
    }

    public override int GetHashCode()
    {
        return string.Format("{0}_{1}_{2}_{3}",Customer,Filename,Reference,(Date == null ? "" : Date.Value.ToString())).GetHashCode();
    }
}

I will be retrieving 2 lists of this class – what I want to do is to compare the two, and get ones that don’t exist in both. So if an item exists in x list but not in y, I want to perform an action for the items in this list. If an item exists in y list but not in x, I want to do a different action.

How would I do this? Using LINQ I guess!

EDIT: Performance is not much of an issue – this will only be run once

Answer 1

It sounds like you just want Except:

foreach (var newItem in firstList.Except(secondList))
{
    ...
}

As an aside:

• That’s not a terribly nice way of generating a hash code – search for other questions here.
• Delegate from Equals(object) to Equals(DocumentCompare) to avoid repetitive logic
• Mutable types aren’t great candidates for equality comparisons (in particular, one you’ve used a value as a key in a dictionary, if you change the equality-sensitive components you won’t be able to find the key again)
• Even if you do want it to be mutable, properties are better for encapsulation than public fields
• I would either seal the type or check whether the two objects are exactly the same type, as otherwise you could end up with asymmetric equality