LINQ：通过使它们可转换/可比较来对不同类型的集合使用 .Except() 吗？

Question

给定两个不同类型的列表，是否可以使这些类型相互转换或相互比较（例如使用 TypeConverter 或类似的），以便 LINQ 查询可以比较它们？ 我在 SO 上看到了其他类似的问题，但没有任何内容表明类型可以相互转换以解决问题。

收藏类型：

public class Data
{
    public int ID { get; set; }
}

public class ViewModel
{
    private Data _data;

    public ViewModel(Data data)
    {
        _data = data;
    }
}

预期用途：

    public void DoMerge(ObservableCollection<ViewModel> destination, IEnumerable<Data> data)
    {
        // 1. Find items in data that don't already exist in destination
        var newData = destination.Except(data);

        // ...
    }

由于我知道如何将 ViewModel 的实例与 Data 的实例进行比较，这似乎是合乎逻辑的，因此我应该能够提供一些比较逻辑，然后 LINQ 将其用于 .Except() 之类的查询。 这可能吗？

Answer 1

我认为提供从Data到ViewModel的投影是有问题的，所以除了 Jason 之外，我还提供了另一种解决方案。

除了使用散列集（如果我没记错的话），因此您可以通过创建自己的散列集来获得类似的性能。 我还假设当Data对象的IDs相等时，您将它们IDs为相等。

var oldIDs = new HashSet<int>(data.Select(d => d.ID));
var newData = destination.Where(vm => !oldIDs.Contains(vm.Data.ID));

您可能在方法中的其他地方还有“oldData”集合的另一个用途，在这种情况下，您可能想要这样做。 在您的数据类上实现IEquatable<Data> ，或为散列集创建自定义IEqualityComparer<Data> ：

var oldData = new HashSet<Data>(data);
//or: var oldData = new HashSet<Data>(data, new DataEqualityComparer());
var newData = destination.Where(vm => !oldData.Contains(vm.Data));

Answer 2

如果你使用这个：

var newData = destination.Except(data.Select(x => f(x)));

您必须将“数据”投影到“目的地”中包含的相同类型，但使用下面的代码可以摆脱此限制：

//Here is how you can compare two different sets.
class A { public string Bar { get; set; } }
class B { public string Foo { get; set; } }

IEnumerable<A> setOfA = new A[] { /*...*/ };
IEnumerable<B> setOfB = new B[] { /*...*/ };
var subSetOfA1 = setOfA.Except(setOfB, a => a.Bar, b => b.Foo);

//alternatively you can do it with a custom EqualityComparer, if your not case sensitive for instance.
var subSetOfA2 = setOfA.Except(setOfB, a => a.Bar, b => b.Foo, StringComparer.OrdinalIgnoreCase);

//Here is the extension class definition allowing you to use the code above
public static class IEnumerableExtension
{
    public static IEnumerable<TFirst> Except<TFirst, TSecond, TCompared>(
        this IEnumerable<TFirst> first,
        IEnumerable<TSecond> second,
        Func<TFirst, TCompared> firstSelect,
        Func<TSecond, TCompared> secondSelect)
    {
        return Except(first, second, firstSelect, secondSelect, EqualityComparer<TCompared>.Default);
    }

    public static IEnumerable<TFirst> Except<TFirst, TSecond, TCompared>(
        this IEnumerable<TFirst> first,
        IEnumerable<TSecond> second,
        Func<TFirst, TCompared> firstSelect,
        Func<TSecond, TCompared> secondSelect,
        IEqualityComparer<TCompared> comparer)
    {
        if (first == null)
            throw new ArgumentNullException("first");
        if (second == null)
            throw new ArgumentNullException("second");
        return ExceptIterator<TFirst, TSecond, TCompared>(first, second, firstSelect, secondSelect, comparer);
    }

    private static IEnumerable<TFirst> ExceptIterator<TFirst, TSecond, TCompared>(
        IEnumerable<TFirst> first,
        IEnumerable<TSecond> second,
        Func<TFirst, TCompared> firstSelect,
        Func<TSecond, TCompared> secondSelect,
        IEqualityComparer<TCompared> comparer)
    {
        HashSet<TCompared> set = new HashSet<TCompared>(second.Select(secondSelect), comparer);
        foreach (TFirst tSource1 in first)
            if (set.Add(firstSelect(tSource1)))
                yield return tSource1;
    }
}

有些人可能会争辩说，由于使用了 HashSet，内存效率低下。 但实际上，框架的 Enumerable.Except 方法对一个名为“Set”的类似内部类做了同样的事情（我通过反编译看了看）。

Answer 3

最好的办法是提供从Data到ViewModel的投影，以便您可以说

var newData = destination.Except(data.Select(x => f(x)));

其中f将Data映射到ViewModel 。 您还需要一个IEqualityComparer<Data> 。

Answer 4

我知道这已经很晚了，但是使用 Func 有一个更简单的语法，它消除了对比较器的需要。

public static class LinqExtensions
{
   public static IEnumerable<TSource> Except<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
   {
       return first.Where(x => second.Count(y => comparer(x, y)) == 0);
   }

   public static IEnumerable<TSource> Contains<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
   {
       return first.Where(x => second.FirstOrDefault(y => comparer(x, y)) != null);
   }

   public static IEnumerable<TSource> Intersect<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
   {
       return first.Where(x => second.Count(y => comparer(x, y)) == 1);
   }
}

所以对于 Foo 和 Bar 类的列表

public class Bar
{
   public int Id { get; set; }
   public string OtherBar { get; set; }
}

public class Foo
{
   public int Id { get; set; }
   public string OtherFoo { get; set; }
}

可以运行 Linq 语句，例如

var fooExceptBar = fooList.Except(barList, (f, b) => f.Id == b.Id);
var barExceptFoo = barList.Except(fooList, (b, f) => b.OtherBar == f.OtherFoo);

它基本上与上面的略有不同，但对我来说似乎更清晰。