Y a-t-il un moyen de faire la différence entre deux ensembles d'objets en c #

Question

Je veux connaître la différence entre deux ensembles d’ints en c #. Étant donné s1 et s2, je veux renvoyer les ints qui sont en s1 et non en s2. Je peux faire quelque chose comme:

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

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

Mais je me demandais si quelqu'un pouvait signaler quelque chose de plus propre. Je voudrais faire quelque chose comme

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

Vous ne savez pas s’il existe une méthode ou une construction LINQ que quiconque pourrait signaler? Merci.

Answer 1

Je pense que vous souhaitez HashSet.Except . C'est-à-dire que, plutôt que d'utiliser des listes, utilisez HashSets, puis l'opération est disponible. C'est un meilleur type si ce que vous représentez est vraiment un «ensemble» de toute façon. (Si vous avez déjà une liste, vous pouvez simplement en créer un "nouveau HashSet".)

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

Voici deux méthodes d'extension qui peuvent s'avérer utiles lorsque vous devez trouver des différences non ordonnées entre deux IEnumerable (c'est plus ou moins la même chose que la réponse donnée par le wrapper Leppie dans les méthodes d'extension):

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

Autre API utile, obtenez la différence symétrique:

HashSet.SymmetricExceptWith ()