IEqualityComparer on different types

Question

Given two classes

class Contract
{
    public int ID {get; set;}
    // . . . 
}

class DBContract
{
    public int FromID {get; set;}
    // . . . 
}

And two IEnumerables

IEnumerable<Contract> ValidContracts = Application.GetContracts(//. . .
IEnumerable<DBContract> ExportedContracts = DBAdapter.GetRows(// . . .

I need to find intersection of theese IEnumerables. But how do I implement IEqualityComparer, if it only has one type argument?

You could let them implement a common interface like `IDBContract`, then provide an `IEqualityComparer`. — Tim Schmelter, May 15 '17 at 07:41
What should be the result? `Contract`, `DBContract`, something else ? — Ofir Winegarten, May 15 '17 at 07:42
@OfirWinegarten that question made me think my question is incorrect. Actually I seek `Contract` as result — Dmitry Pavlushin, May 15 '17 at 07:43
So you can use Patrick's answer, just the other way around `ValidContracts.Where (... ExportedContracts.Any ...` — Ofir Winegarten, May 15 '17 at 07:47

score 7 · Accepted Answer · answered May 15 '17 at 07:43

7

Why not use Where and Any instead? It is not as performant as Intersect, but it allows you to filter the way you want:

var list = ExportedContracts.Where(ec => ValidContracts.Any(vc => vc.ID == ec.FromID));

You can't use IEqualityComparer here since the object doesn't have any interface or base class (except object).

answered May 15 '17 at 07:43

Patrick Hofman

153,850
22
249
325

Before doing that, I would convert `ValidContracts` to an array or list. – xanatos May 15 '17 at 07:53
1

Yeah, that might be a good idea. Or even a dictionary to improve performance. – Patrick Hofman May 15 '17 at 07:54
@xanatos it is actually a custom class implementing `IList`, `ICollection` ans `IEnumebable` – Dmitry Pavlushin May 15 '17 at 07:55

Sergey Kalinichenko · Answer 2 · 2017-05-15T07:49:12.317

In order to operate on a collection of mixed types an IEqualityComparer<T>'s type argument T must accept a common ancestor of all types in the collection.

Since Contract and DbContract appear unrelated, and do not share a common interface, you need to use object as the universal base class.

This may be too complicated for your purposes: perhaps you could implement intersection by ID as follows:

var commonIds = new HashSet<int>(contracts.Select(c => c.Id));
commonIds.IntersectWith(dbContracts.Select(dbc => dbc.FromId));

Now commonIds has IDs of the objects that you need. Running simple Wheres on both sides would produce two statically-typed parts of the intersection:

var commonContracts = contracts.Where(c => commonIds.Contains(c.Id));
var commonDbContracts = dbContracts.Where(dbc => commonIds.Contains(dbc.FromId));

score 2 · Answer 3 · answered May 15 '17 at 07:44

I would create a temporary container for Contract/DBContract:

public class ContractDbContract
{
    public Contract Contract;
    public DBContract DBContract;

    public int ID 
    {
        get
        {
            return Contract?.ID ?? DBContract.FromID;
        }

    }
}

IEnumerable<Contract> ValidContracts = Application.GetContracts(//. . .
IEnumerable<DBContracts> ExportedContracts = DBAdapter.GetRows(// . . .

var validContracts2 = ValidContracts.Select(x => new ContractDbContract { Contract = x });
var exportedContracts2 = ExportedContracts.Select(x => new ContractDbContract { DBContract = x });

Now you can intersect validContracts2 and exportedContracts2 however you want, and then it is easy to "extract" the Contract/DBContract from the ContractDBContract

score 1 · Answer 4 · edited May 23 '17 at 10:31

If they can't let them implement the same interface like IDBContract and provide a custom IEqualityComparer<IDBContract> you can't use Intersect but you could use Enumerable.Join:

var commonContracts = from c in ValidContracts
                      join ec in ExportedContracts on c.ID equals ec.FromID
                      select new { contract = c, exportedContract = ec };

Join also uses a set based approach so it's more efficient than Where:

Why is LINQ JOIN so much faster than linking with WHERE?

score 1 · Answer 5 · answered Oct 01 '18 at 09:03

You could implement Intersect yourself, but without using HashSet, something like:

public static IEnumerable<TFirst> Intersect<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second,
    Func<TFirst, TSecond, bool> comparerFunc)
{
    return first.Where(firstItem => second.Any(secondItem => comparerFunc(firstItem, secondItem)));
}

And use it like:

IEnumerable<Contract> ValidContracts = Application.GetContracts(//. . .
IEnumerable<DBContract> ExportedContracts = DBAdapter.GetRows(// . . .

var intersect = ValidContracts.Intersect(ExportedContracts, (contract, dbContract) => contract.ID == dbContract.FromID);

IEqualityComparer on different types

5 Answers5