帮助对 except 扩展方法进行新的覆盖

Question

我想编写一个新的重写 Except< IEnumerable 的 /code>扩展方法能够内联比较器，而不是使用 IEqualityComparer。

A、B 是引用类型的集合。

类似这样的内容：

A: [1, A], [2, A], [3, A]

B: [3, B], [4, B], [5, B]

C = A.Except(B, (a,b) => a.Id == b.Id);

C: [1, A], [2, A]

我想知道您是否可以帮助我编写该方法的代码。

public static class IEnumerableExntesion
    {
        public IEnumerable<T> Except<T>(this IEnumerable<T> source, 
                                        IEnumerable<T> second, 
                                        Func<T, T, bool> predicate)
        {

        }
    }

我在想：

return source.Where (s => !second.Any(p => p.Id == s.Id));

但实际上我无法使用传递的谓词将其转换为通用解决方案！

任何帮助！

Answer 1

您是否需要使用谓词进行比较，或者可以使用投影来比较投影值吗？如果是这样，那么您可以使用某种 ExceptBy 方法：

var c = a.ExceptBy(b, x => x.Id);

var r = p.ExceptBy(q, x => x.Name, StringComparer.OrdinalIgnoreCase);

// ...

public static class EnumerableExtensions
{
    public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
        this IEnumerable<TSource> first, IEnumerable<TSource> second,
        Func<TSource, TKey> keySelector,
        IEqualityComparer<TKey> keyComparer = null)
    {
        if (first == null) throw new ArgumentNullException("first");
        if (second == null) throw new ArgumentNullException("second");
        if (keySelector == null) throw new ArgumentNullException("keySelector");

        return first.ExceptByIterator(second, keySelector, keyComparer);
    }

    private static IEnumerable<TSource> ExceptByIterator<TSource, TKey>(
        this IEnumerable<TSource> first, IEnumerable<TSource> second,
        Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        var keys = new HashSet<TKey>(second.Select(keySelector), keyComparer);

        foreach (TSource item in first)
        {
            if (keys.Add(keySelector(item)))
                yield return item;
        }
    }
}

Answer 2

这应该有效：

return source.Where(s => !second.Any(p => predicate(s, p))

Answer 3

return source.Where(s => !second.Any(p => predicate(p, s)));

Answer 4

我会使用您传递的 Func 来创建通用 IEqualityComparer 并将其传递给常规 Except：

public class PredicateEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> _predicate;

    public PredicateEqualityComparer(Func<T, T, bool> predicate)
    {
        _predicate = predicate;
    }

    public bool Equals(T x, T y)
    {
        return _predicate(x, y);
    }

    public int GetHashCode(T x)
    {
        return 0;
    }
}

您的扩展方法：

public static class IEnumerableExntesion
{
    public IEnumerable<T> Except<T>(this IEnumerable<T> source, 
                                    IEnumerable<T> second, 
                                    Func<T, T, bool> predicate)
    {
        return source.Except(second, new PredicateEqualityComparer(predicate));
    }
}    

请注意，我有存根 GetHashCode 实现，最好正确实现它，但您必须为其传递另一个委托。