Gibt es eine Möglichkeit, den Unterschied zwischen zwei Gruppen von Objekten in c # zu erhalten

Question

Ich mag den Unterschied zwischen zwei Sätzen von Ints in c # erhalten. Gegeben s1 und s2 Ich möchte diese ints zurück, die in s1 sind und nicht in s2. Ich kann etwas tun, wie zum Beispiel:

    List<int> s1 = new List<int>();
    List<int> s2 = new List<int>();

    foreach (int i in s1)
    {
        if (s1.Contains(i))
        {
            //
        }
        else
        {
            //
        }
    }

Aber ich habe mich gefragt, ob jemand etwas darauf hin, Reiniger kann. Ich möchte etwas wie

tun

List<int> omitted = s1.Difference(s2);

Nicht sicher, ob es bereits eine Methode oder ein LINQ konstruieren, dass jemand in der Lage sein könnte, darauf hinzuweisen? Danke.

Answer 1

Ich glaube, Sie wollen HashSet.Except . Das heißt, anstatt Verwendung Listen, Verwendung HashSets, und dann ist der Betrieb zur Verfügung. Dies ist eine bessere Art, wenn, was Sie repräsentieren wirklich ein ‚Set‘ ist sowieso. (Wenn Sie bereits eine Liste haben, können Sie einfach eine ‚neue HashSet‘ erstellen aus ihm heraus.)

Answer 2

IEnumerable<T> a, b;

var added = a.Except(b);
var removed = b.Except(a);

Answer 3

List<int> s1 = new List<int>();
List<int> s2 = new List<int>();

return sl.FindAll( i => !s2.Contains(i) )

Answer 4

from x in s1
where ! s2.contains(x)
select x

Answer 5

Hier sind zwei Erweiterungsmethoden, die praktisch könnte kommen, wenn Sie ungeordnete Unterschiede zwischen zwei IEnumerable finden müssen (es ist mehr oder weniger die gleiche wie die Antwort von leppie Wrapper in Erweiterungsmethoden angegeben):

public class EnumerableDifferences<T>
{
    public IEnumerable<T> Added { get; }
    public IEnumerable<T> Removed { get; }

    public EnumerableDifferences(IEnumerable<T> added, IEnumerable<T> removed)
    {
        Added = added;
        Removed = removed;
    }
}

public static class EnumerableExtensions
{
    public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
    {
        return new HashSet<TSource>(source, comparer);
    }

    public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer = null)
    {
        return first
            .ExceptBy(keySelector, second.Select(keySelector), keyComparer);
    }

    public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEnumerable<TKey> keys, IEqualityComparer<TKey> keyComparer = null)
    {
        var secondKeys = keys.ToHashSet(keyComparer);

        foreach (var firstItem in source)
        {
            var firstItemKey = keySelector(firstItem);

            if (!secondKeys.Contains(firstItemKey))
            {
                yield return firstItem;
            }
        }
    }

    public static EnumerableDifferences<TSource> DifferencesBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer = null)
    {
        keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;

        var removed = first.ExceptBy(second, keySelector, keyComparer);
        var added = second.ExceptBy(first, keySelector, keyComparer);

        var result = new EnumerableDifferences<TSource>(added, removed);

        return result;
    }

    public static EnumerableDifferences<TSource> Differences<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer = null)
    {
        return first
            .DifferencesBy(second, x => x, comparer);
    }
}

public static class Program
{
    public static void Main(params string[] args)
    {
        var l1 = new[] { 'a', 'b', 'c' };
        var l2 = new[] { 'a', 'd', 'c' };

        var result = l1.Differences(l2);

        Console.ReadKey();
    }
}

Answer 6

Eine weitere nützliche API erhalten Sie die symmetrische Differenz:

HashSet.SymmetricExceptWith ()