比较两个列表的最快方法<CustomObject>

Question

I have two List<CustomObject> , called list1 and list2

public class CustomObject
{
    public string foo { get; set; }
    public string bar{ get; set; }
}

The goal is to generate a new list with all the entries that have been modified/added in list2.

Because these lists can get pretty long, looping through them is not an option ...

Any ideas?

Answer 1

Here's a traditional way to do it:

public class CustomObject : IComparable
{
    public string foo { get; set; }
    public string bar{ get; set; }
    public int CompareTo(CustomObject o)
    {
         if (this.foo == o.foo && this.bar == o.bar) return 0;

         //We have to code for the < and > comparisons too.  Could get painful if there are a lot of properties to compare.
         if (this.Foo == o.Foo) return (this.Bar.CompareTo(o.Bar));
         return this.Foo.CompareTo(o.Foo);
    }
}

Then use Linq.Except :

listA.Except(listB)

Answer 2

Adding another answer to accomodate some additional NFRs that have come up in the comments:

1. Objects can be identified by a hash code
2. The list is very big, so performance is an issue
3. The idea is to compare an old list to a new list to see if any new hash codes have popped up.

You will want to store your objects in a dictionary:

var list = new Dictionary<string, CustomObject>();

When you add them, provide the hash as the key:

list.Add(customObject.Hash, customObject);

To scan for new ones:

var difference = new List<CustomObject>();
foreach (customObject o in newList)
{
    if (oldList.ContainsKey(o.Hash)) difference.Add(o);
}
Log(String.Format("{0} new hashes found.", difference.Count));

By using the Dictionary you take advantage of the way the keys are stored in a hash table. Finding an item in a hash table is faster than just doing a scan & compare sort of thing. I believe this will be O(n*log(n)) instead of O(n^2).