Joining two IEnumerable<T>

Question

I'm trying to merge two nodes. Basically, the idea is to take all children in left and new ones in right. Is there any way to get rid of toAdd variable and do it in a clean way?

I don't want to convert any IEnumerable<T> to List or Array in this merge process.

public IEnumerable<TChild> NodeMerge<TNode, TChild, TKey>(TNode left, TNode right,
Func<TNode, IEnumerable<TChild>> getChildren, Func<TChild, TKey> getKey)
{
    var lChildren = getChildren(left);
    var rChildren = getChildren(right);

    IEnumerable<TChild>[] toAdd = new IEnumerable<TChild>[2];

    // Common Keys between left and right
    toAdd[0] = lChildren.Where(s => rChildren.Select(p => getKey(p)).Contains(getKey(s)));

    // new keys added to right
    toAdd[1] = rChildren.Where(s => lChildren.Select(p => getKey(p)).Contains(getKey(s)) == false);

    return toAdd.SelectMany(s => s);
}

Answer 1

public IEnumerable<TChild> NodeMerge<TNode, TChild, TKey>(TNode left, TNode right,
    Func<TNode, IEnumerable<TChild>> getChildren,
    Func<TChild, TKey> getKey)
{
    var lChildren = getChildren(left);
    var rChildren = getChildren(right);

    return lChildren
        .Intersect(rChildren, new FuncComparer<TChild, TKey>(getKey))
        .Concat(
            rChildren
               .Except(lChildren, new FuncComparer<TChild, TKey>(getKey))
        );
}

With this helper class:

public class FuncComparer<T, TKey> : IEqualityComparer<T> 
{
    readonly Func<T, TKey> getKey;
    readonly EqualityComparer<TKey> comparer;

    public FuncComparer(Func<T, TKey> getKey) 
    { 
        this.getKey = getKey;
        this.comparer = EqualityComparer<TKey>.Default;
    }
    public bool Equals(T x, T y) 
    {
        return comparer.Equals(getKey(x), getKey(y));
    }

    public int GetHashCode(T obj) 
    {
        return comparer.GetHashCode(getKey(obj));
    }
}

Answer 2

Little cleaner:

// Common Keys between left and right
var result = lChildren.Where(s => rChildren.Select(p => getKey(p)).Contains(getKey(s))).ToList();

// new keys added to right
result.AddRange(rChildren.Where(s => lChildren.Select(p => getKey(p)).Contains(getKey(s)) == false));

return result;

Without ToList():

public static IEnumerable<T> Merge<T>(this IEnumerable<T> first, IEnumerable<T> second)
{
    foreach (var item in first)
        yield return item;

    foreach (var item in second)
        yield return item;
}

In your NodeMerge method:

return lChildren.Where(s => rChildren.Select(p => getKey(p)).Contains(getKey(s))).Merge(rChildren.Where(s => lChildren.Select(p => getKey(p)).Contains(getKey(s)) == false));

Answer 3

You can do this with vanilla Linq. The question is whether you want all keys on the left plus new keys from the right (a "full join") or common keys between left and right plus all keys on the right (a "right join"):

var lChildren = getChildren(left);
var rChildren = getChildren(right);
var lKeys = lChildren.Select(getKey);
var rKeys = rChildren.Select(getKey);

var fullJoin = lChildren
    .Concat(rChildren.Where(r=>!lKeys.Contains(getKey(r)));

var rightJoin = lChildren.Where(l=>!rKeys.Contains(getKey(l)))
    .Concat(rChildren.Where(r=>!lKeys.Contains(getKey(r)));