Use IEqualityComparer to generate a distinct list based on two properties in C#

Question

I am trying to generate a listbox of items that is a concatenation of two strings. I have created a class that implements IEqualityComparer and I want to make this list distinct.

private void PopulateFamily()
    {
        var source = _mfgOrdersData
            .Select(o => new FamilySelector(o.ItemWrapper.ItemClass, o.ItemWrapper.Family))
            .Distinct()
            .OrderBy(f => f.CodeFamily)
            .ToList();

        FamilyFilterListBox.DataSource = source;
        FamilyFilterListBox.ValueMember = "Family";
        FamilyFilterListBox.DisplayMember = "CodeFamily";
    }

class FamilySelector : IEqualityComparer<FamilySelector>
{
    public FamilySelector(string code, string family)
    {
        Code = code;
        Family = family;
    }

    public string Code { get; set; }
    public string Family { get; set; }
    public string CodeFamily { get { return string.Format("{0}\t{1}", Code, Family); } }

    public bool Equals(FamilySelector x, FamilySelector y)
    {
        return x.Code == y.Code && x.Family == y.Family;
    }

    public int GetHashCode(FamilySelector obj)
    {
        return obj.Code.GetHashCode() ^ obj.Family.GetHashCode();
    }
}

The problem is that I am getting the list non distinct. The same item appears multiple times. I presume that Equals() or GetHashCode() are not implemented correctly.

If Implementing the IEqualityComparer proves difficult, there is another way: https://stackoverflow.com/a/491832/8155 — Amy B, Apr 01 '18 at 08:29
`IEqualityComparer` is for a class whose role is to do the comparing. You'd have to pass one as the argument to `Distinct`. `IEquatable` on the other hand, is for a class whose instances can be compared for equality. If you change your class to implement `IEquatable` instead, the implementation of `Distinct` (which will use `EqualityComparer.Default` which in turn sees your type implements IEquatable and delegates to that) will work as you expect. — pinkfloydx33, Apr 01 '18 at 09:42
@pinkfloydx33 Your comment is the correct answer btw. OP just messed up the interface they need to implement. — Ivan Stoev, Apr 01 '18 at 14:34

CodeFuller · Accepted Answer · 2018-04-01T09:03:41.473

Currently you run Distinct() on a collection of FamilySelector instances which results to comparing by reference equality.

To do it right, you should pass an instance of IEqualityComparer to Distinct() call:

var source = _mfgOrdersData
    .Select(o => new FamilySelector(o.ItemWrapper.ItemClass, o.ItemWrapper.Family))
    .Distinct(new FamilySelector())
    .OrderBy(f => f.CodeFamily)
    .ToList();

You should add parameterless constructor to FamilySelector class so that code could be compiled.

I'd also suggest small refactoring of FamilySelector class. Currently it holds the data and performs comparison. Usually implementation of IEqualityComparer is a data-less class that just performs a comparison:

class FamilyData
{
    public FamilyData(string code, string family)
    {
        Code = code;
        Family = family;
    }

    public string Code { get; set; }
    public string Family { get; set; }
    public string CodeFamily { get { return string.Format("{0}\t{1}", Code, Family); } }
}

class FamilySelector : IEqualityComparer<FamilyData>
{
    public bool Equals(FamilyData x, FamilyData y)
    {
        return x.Code == y.Code && x.Family == y.Family;
    }

    public int GetHashCode(FamilyData obj)
    {
        return obj.Code.GetHashCode() ^ obj.Family.GetHashCode();
    }
}

var source = _mfgOrdersData
    .Select(o => new FamilyData(o.ItemWrapper.ItemClass, o.ItemWrapper.Family))
    .Distinct(new FamilySelector())
    .OrderBy(f => f.CodeFamily)
    .ToList();

Or make it implement `IEquatable` instead – pinkfloydx33 Apr 01 '18 at 09:37 — pinkfloydx33, Apr 01 '18 at 09:37
Correct, that's another way to go. – CodeFuller Apr 01 '18 at 09:42 — CodeFuller, Apr 01 '18 at 09:42

score 2 · Answer 2 · answered Apr 01 '18 at 11:56

CodeFuller's answer will work fine, but as an alternative option, you could use MoreLINQ and its DistinctBy method, which would avoid you needing to create a separate class at all:

private void PopulateFamily()
{
    var source = _mfgOrdersData
        .Select(o => o.ItemWrapper)
        .DistinctBy(o => new { o.ItemClass, o.Family })
        .OrderBy(f => f.CodeFamily)
        .ToList();

    FamilyFilterListBox.DataSource = source;
    FamilyFilterListBox.ValueMember = "Family";
    FamilyFilterListBox.DisplayMember = "CodeFamily";
}

I've assumed that you want to select ItemWrapper - it's hard to tell without seeing the types involved, but that looks likely to be what you want.

Use IEqualityComparer to generate a distinct list based on two properties in C#

2 Answers2