我可以使用Linq的Except()和lambda表达式比较器吗？

Question

我知道我可以调用linq的Except并指定一个自定义的IEqualityComparer,但为每个数据类型实现一个新的Comparer类似乎是一个过度杀伤的目的.我可以使用lambda表达式来提供相等的函数,比如当我使用Where或其他LINQ函数时？

如果我不能,还有其他选择吗？

Answer 1

对于任何仍在寻找的人; 这是实现自定义lambda比较器的另一种方法.

public class LambdaComparer<T> : IEqualityComparer<T>
    {
        private readonly Func<T, T, bool> _expression;

        public LambdaComparer(Func<T, T, bool> lambda)
        {
            _expression = lambda;
        }

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

        public int GetHashCode(T obj)
        {
            /*
             If you just return 0 for the hash the Equals comparer will kick in. 
             The underlying evaluation checks the hash and then short circuits the evaluation if it is false.
             Otherwise, it checks the Equals. If you force the hash to be true (by assuming 0 for both objects), 
             you will always fall through to the Equals check which is what we are always going for.
            */
            return 0;
        }
    }

然后你可以为linq创建一个扩展,除了一个接受lambda的相交

/// <summary>
        /// Returns all items in the first collection except the ones in the second collection that match the lambda condition
        /// </summary>
        /// <typeparam name="T">The type</typeparam>
        /// <param name="listA">The first list</param>
        /// <param name="listB">The second list</param>
        /// <param name="lambda">The filter expression</param>
        /// <returns>The filtered list</returns>
        public static IEnumerable<T> Except<T>(this IEnumerable<T> listA, IEnumerable<T> listB, Func<T, T, bool> lambda)
        {
            return listA.Except(listB, new LambdaComparer<T>(lambda));
        }

        /// <summary>
        /// Returns all items in the first collection that intersect the ones in the second collection that match the lambda condition
        /// </summary>
        /// <typeparam name="T">The type</typeparam>
        /// <param name="listA">The first list</param>
        /// <param name="listB">The second list</param>
        /// <param name="lambda">The filter expression</param>
        /// <returns>The filtered list</returns>
        public static IEnumerable<T> Intersect<T>(this IEnumerable<T> listA, IEnumerable<T> listB, Func<T, T, bool> lambda)
        {
            return listA.Intersect(listB, new LambdaComparer<T>(lambda));
        }

用法:

var availableItems = allItems.Except(filterItems, (p, p1) => p.Id== p1.Id);

Answer 2

你能否使用带有lambda的.Where过滤掉你所需的值？

请求示例:

    static void Main(string[] args)
    {
        var firstCustomers = new[] { new Customer { Id = 1, Name = "Bob" }, new Customer { Id = 2, Name = "Steve" } };
        var secondCustomers = new[] { new Customer { Id = 2, Name = "Steve" }, new Customer { Id = 3, Name = "John" } };

        var customers = secondCustomers.Where(c => !firstCustomers.Select(fc => fc.Id).Contains(c.Id));
    }

    public class Customer
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

Answer 3

我认为你不能直接使用基本的LINQ接口,但是我看到人们用扩展方法实现了一个LambdaComparer类,这将有助于你做到这一点.

这是一个例子

Answer 4

这是我掀起的简单事情:

public class CustomComparer<TSource, TCompareType> : IEqualityComparer<TSource> where TSource : class 
{
    private readonly Func<TSource, TCompareType> getComparisonObject;
    public CustomComparer(Func<TSource,TCompareType> getComparisonObject)
    {
        if (getComparisonObject == null) throw new ArgumentNullException("getComparisonObject");
        this.getComparisonObject = getComparisonObject;
    } 

    /// <summary>
    /// Determines whether the specified objects are equal.
    /// </summary>
    /// <returns>
    /// true if the specified objects are equal; otherwise, false.
    /// </returns>
    /// <param name="x">The first object of type <paramref name="T"/> to compare.
    ///                 </param><param name="y">The second object of type <paramref name="T"/> to compare.
    ///                 </param>
    public bool Equals(TSource x, TSource y)
    {
        if (x == null)
        {
            return (y == null);
        }
        else if (y == null)
        {
            return false;
        }
        return EqualityComparer<TCompareType>.Default.Equals(getComparisonObject(x), getComparisonObject(y));
    }

    /// <summary>
    /// Returns a hash code for the specified object.
    /// </summary>
    /// <returns>
    /// A hash code for the specified object.
    /// </returns>
    /// <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.
    ///                 </param><exception cref="T:System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.
    ///                 </exception>
    public int GetHashCode(TSource obj)
    {
        return EqualityComparer<TCompareType>.Default.GetHashCode(getComparisonObject(obj));
    }
}

用法:

var myItems = allItems.Except(theirItems, new CustomComparer(item => item.Name));