Est-il un moyen pour avoir la différence entre deux ensembles d'objets en c#

Je veux obtenir la différence entre deux ensembles d'entiers en c#. Compte tenu de la s1 et la s2, je veux le retour de ces entiers qui sont dans s1 et pas dans 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 peut indiquer quelque chose de plus propre. Je voudrais faire quelque chose comme

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

Vous ne savez pas si il existe une méthode ou d'un LINQ construire que quelqu'un pourrait être en mesure de préciser? Merci.

OriginalL'auteur SiC | 2009-04-30

  1. 22

    Je pense que vous voulez HashSet.Sauf. C'est, 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, c'est vraiment un " set " de toute façon. (Si vous avez déjà une liste, il vous suffit de créer un "new HashSet').

    génial merci. À l'exception de() est la méthode que je cherchais et je prends tes conseils sur HashSets.
    L'exception est une extension de la fonction, non?
    Il y a une méthode d'extension Énumérable.Sauf pour tous les IEnumerables. Mais HashSet a une méthode à l'Exception spécifiquement pour HashSets.
    L'exception est en effet une méthode d'extension qui fonctionne sur n'importe quel IEnumerable (voir msdn.microsoft.com/en-us/library/...). Cela signifie qu'il fonctionne bien sur la Liste<T>. Bien sûr, si l'ordre n'a pas d'importance HashSet /est/ un plus type approprié.
    Brian, je ne le pense pas. La méthode ci-dessus est la méthode d'extension. HashSet a un ExceptWith méthode destructive supprime les éléments dans le paramètre à partir de l'instance HashSet, mais pas de l'Exception.

    OriginalL'auteur

  2. 22
    IEnumerable<T> a, b;

var added = a.Except(b);
var removed = b.Except(a);
    Notez que cela utilise Énumérable.Sauf, si vous avez besoin d'utiliser le Système.Linq. msdn.microsoft.com/en-us/library/bb300779.aspx
    Est-ce un problème? 🙂
    Problème? Non, je voulais juste aider quelqu'un qui pourrait couper-coller ce code et de trouver que cela ne compile pas.
    La même mise en garde s'applique également à votre propre réponse. HashSet ne pas mettre en œuvre son propre Sauf la méthode, donc votre réponse nécessite Système.Linq trop.
    Mais le vôtre exécuter en O(n^2) et la mine en O(n) 🙂

    OriginalL'auteur

  3. 2
    List<int> s1 = new List<int>();
List<int> s2 = new List<int>();

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

    OriginalL'auteur

  4. 1
    de x dans s1 
où les ! s2.contient(x) 
sélectionnez x

    OriginalL'auteur

  5. 0

    Voici deux méthodes d'extension qui peut être pratique lorsque vous avez besoin de trouver non ordonnée des différences entre les deux IEnumerable (c'est plus ou moins la même que la réponse donnée par leppie wrapper 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();
}
}

    OriginalL'auteur

  6. 0

    Autre API, obtenir le symétrique différence:

    HashSet.SymmetricExceptWith()

    OriginalL'auteur