MVC LINQ Union with compare IComparer vs IEqualityComparer

Question

I have an example class

public class Item 
{
    public int Id;
    public string Name;
    public int ItemParentId;
}

then I put many Items into the database, there they have an Id, Name and ItemParentId, but I also create a list of new Items, where they have Name, ItemParentId, but Id = 0;

I do select all items from database to list1. I create new list2 with new Items.

I want to make something like this:

list1.Union(list2); // need to combine only with different ItemParentId

but the problem is that I need to combine only those items, which ItemParentId are not equal. Linq Union only let to create IEqualityComparer, but this one is not suitable. Also I tried IComparer, but Union doesn't let use it. Any help would be appreciated.

Example of lists and what result I want:

var list1 = { 
       Item { Id = 1, Name = "item1", ItemParentId = 100 },
       Item { Id = 2, Name = "item2", ItemParentId = 200 },
       Item { Id = 3, Name = "item3", ItemParentId = 300 },
       Item { Id = 4, Name = "item4", ItemParentId = 400 }
  } 

var list2 = new List<Item>{ 
       new Item { Id = 0, Name = "item5", ItemParentId = 500 },
       new Item { Id = 0, Name = "item6", ItemParentId = 300 },
       new Item { Id = 0, Name = "item7", ItemParentId = 400 },
  }

result list should contain 3 items, which names are "item1", "item2", "item3", "item4" and "item5"

UPDATE:

thanks guys, with your help I managed to compare items by single property, but now I have to do that by two of them. Actually my lass has now 10 properties, but I have to compare only by two, the comparer looks fine, only thing I want to know is what do the HashCode used for?

Answer 1

Seems is like IEqualityComparer is what you want after all:

public class Comparer : IEqualityComparer<Item>
{
    public bool Equals(Item x, Item y)
    {
        return x.ItemParentId == y.ItemParentId;
    }

    public int GetHashCode(Item obj)
    { 
        return obj.ItemParentId;
    }
}

Calling code:

var result = list1.Union(list2, new Comparer())

Update: If you want to compare multiple properties, you can alter the comparer:

public class Comparer : IEqualityComparer<Item>
{
    public bool Equals(Item x, Item y)
    {
        return x.ItemParentId == y.ItemParentId 
            || x.Name == y.Name;
    }

    public int GetHashCode(Item obj)
    {
        unchecked 
        {
            int hash = 17;
            hash = hash * 23 + obj.ItemParentId.GetHashCode();
            hash = hash * 23 + obj.Name.GetHashCode();
            return hash;
        }
    }
}

To learn more about the GetHashCode implementation see this answer.

And to learn more about the GetHashCode in general see these answers.

You probably noticed that if you just return 1 or something from the GetHashCode method that your code still works. If you do not implement GetHashCode Union will call Equals which will work but is slower than GetHashCode. Implementing GetHashCode increases performance.

Answer 2

If it's linq-to-objects then you can indeed use an IEqualityComparer:

public class ByParentIdComparer : IEqualityComparer<Item>
{
  public bool Equals(Item x, Item y)
  {
    return x.ItemParentId == y.ItemParentId;
  }
  public int GetHashCode(Item obj)
  { 
    return obj.ItemParentId;
  }
}

Then:

list1.Union(list2, new ByParentIdComparer())

Will work.

This though won't translate well into SQL. If you might be doing the unioning on a database then you're better off with:

list1.Concat(list2).GroupBy(item => item.ItemParentId).Select(grp => grp.First())

Which takes both lists (not yet filtering out duplicates), then groups them by the ItemParentId and then takes the first element from each group, and as such gives the equivalent results.

This will also work in linq-to-objects, but the version using an equality comparer will be faster.

Answer 3

Maybe this helps:

        var list1 = new List<Item>
        {
            new Item { Id = 1, Name = "item1", ItemParentId = 100 },
            new Item { Id = 2, Name = "item2", ItemParentId = 200 },
            new Item { Id = 3, Name = "item3", ItemParentId = 300 },
            new Item { Id = 1, Name = "item4", ItemParentId = 400 }
        };

        var list2 = new List<Item>
        {
            new Item { Id = 0, Name = "item5", ItemParentId = 500 },
            new Item { Id = 0, Name = "item6", ItemParentId = 300 },
            new Item { Id = 0, Name = "item7", ItemParentId = 400 },
        };

        var listMerge = list1.Union(list2.Where(l2 => !list1.Select(l1 => l1.ItemParentId).Contains(l2.ItemParentId))).ToList();

I would personally split that expression in two parts:

        var list2new = list2.Where(l2 => !list1.Select(l1 => l1.ItemParentId).Contains(l2.ItemParentId));
        var listMerge = list1.Union(list2new).ToList();