Le moyen le plus rapide de comparer deux listes génériques pour les différences

Quel est le plus rapide (et le moins gourmand en ressources) pour comparer deux énormes (> 50 000 articles) et, par conséquent, avoir deux listes comme celles ci-dessous:

1. les éléments qui apparaissent dans la première liste mais pas dans la seconde
2. les éléments qui apparaissent dans la deuxième liste mais pas dans la première

Actuellement, je travaille avec List ou IReadOnlyCollection et je résous ce problème dans une requête linq:

var list1 = list.Where(i => !list2.Contains(i)).ToList();
var list2 = list2.Where(i => !list.Contains(i)).ToList();

Mais cela ne fonctionne pas aussi bien que je le souhaiterais. Une idée de rendre cela plus rapide et moins gourmand en ressources car j'ai besoin de traiter un grand nombre de listes?

Utilisation Except:

var firstNotSecond = list1.Except(list2).ToList();
var secondNotFirst = list2.Except(list1).ToList();

Je soupçonne qu'il existe des approches qui seraient en fait légèrement plus rapides que cela, mais même cela sera beaucoup plus rapide que votre approche O (N * M).

Si vous souhaitez les combiner, vous pouvez créer une méthode avec ce qui précède, puis une instruction de retour:

return !firstNotSecond.Any() && !secondNotFirst.Any();

Un point à noter est qu'il est une différence dans les résultats entre le code d' origine dans la question et la solution ici: tous les éléments en double qui ne sont que dans une liste ne seront signalés une fois avec mon code, alors qu'ils seraient signalés comme beaucoup fois qu'ils se produisent dans le code d'origine.

Par exemple, avec les listes de [1, 2, 2, 2, 3]et [1], le résultat "éléments dans list1 mais pas list2" dans le code d'origine serait [2, 2, 2, 3]. Avec mon code, ce serait juste [2, 3]. Dans de nombreux cas, ce ne sera pas un problème, mais cela vaut la peine d'être conscient.

Plus efficace serait d'utiliser Enumerable.Except:

var inListButNotInList2 = list.Except(list2);
var inList2ButNotInList = list2.Except(list);

Cette méthode est implémentée en utilisant une exécution différée. Cela signifie que vous pourriez écrire par exemple:

var first10 = inListButNotInList2.Take(10);

Il est également efficace car il utilise en interne un Set<T>pour comparer les objets. Il fonctionne en collectant d'abord toutes les valeurs distinctes de la deuxième séquence, puis en diffusant les résultats de la première, en vérifiant qu'ils n'ont jamais été vus auparavant.

Enumerable.SequenceEqual, méthode

Détermine si deux séquences sont égales selon un comparateur d'égalité. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Cela fonctionne pour tous les types de données primitifs. Si vous devez l'utiliser sur des objets personnalisés, vous devez l'implémenterIEqualityComparer

Définit des méthodes pour prendre en charge la comparaison d'objets pour l'égalité.

Interface IEqualityComparer

Définit des méthodes pour prendre en charge la comparaison d'objets pour l'égalité. MS.Docs pour IEqualityComparer

Si vous souhaitez que les résultats ne respectent pas la casse , les éléments suivants fonctionneront:

List<string> list1 = new List<string> { "a.dll", "b1.dll" };
List<string> list2 = new List<string> { "A.dll", "b2.dll" };

var firstNotSecond = list1.Except(list2, StringComparer.OrdinalIgnoreCase).ToList();
var secondNotFirst = list2.Except(list1, StringComparer.OrdinalIgnoreCase).ToList();

firstNotSecondcontiendrait b1.dll

secondNotFirstcontiendrait b2.dll

Pas pour ce problème, mais voici du code pour comparer les listes pour égal et non! objets identiques:

public class EquatableList<T> : List<T>, IEquatable<EquatableList<T>> where    T : IEquatable<T>

/// <summary>
/// True, if this contains element with equal property-values
/// </summary>
/// <param name="element">element of Type T</param>
/// <returns>True, if this contains element</returns>
public new Boolean Contains(T element)
{
    return this.Any(t => t.Equals(element));
}

/// <summary>
/// True, if list is equal to this
/// </summary>
/// <param name="list">list</param>
/// <returns>True, if instance equals list</returns>
public Boolean Equals(EquatableList<T> list)
{
    if (list == null) return false;
    return this.All(list.Contains) && list.All(this.Contains);
}

essayez de cette façon:

var difList = list1.Where(a => !list2.Any(a1 => a1.id == a.id))
            .Union(list2.Where(a => !list1.Any(a1 => a1.id == a.id)));

using System.Collections.Generic;
using System.Linq;

namespace YourProject.Extensions
{
    public static class ListExtensions
    {
        public static bool SetwiseEquivalentTo<T>(this List<T> list, List<T> other)
            where T: IEquatable<T>
        {
            if (list.Except(other).Any())
                return false;
            if (other.Except(list).Any())
                return false;
            return true;
        }
    }
}

Parfois, il suffit de savoir si deux listes sont différentes et non pas quelles sont ces différences. Dans ce cas, envisagez d'ajouter cette méthode d'extension à votre projet. Notez que vos objets listés doivent implémenter IEquatable!

Usage:

public sealed class Car : IEquatable<Car>
{
    public Price Price { get; }
    public List<Component> Components { get; }

    ...
    public override bool Equals(object obj)
        => obj is Car other && Equals(other);

    public bool Equals(Car other)
        => Price == other.Price
            && Components.SetwiseEquivalentTo(other.Components);

    public override int GetHashCode()
        => Components.Aggregate(
            Price.GetHashCode(),
            (code, next) => code ^ next.GetHashCode()); // Bitwise XOR
}

Quelle que soit la Componentclasse, les méthodes présentées ici Cardoivent être implémentées de manière presque identique.

Il est très important de noter comment nous avons écrit GetHashCode. Afin d'implémenter correctement IEquatable, Equalset GetHashCode doit fonctionner sur les propriétés de l'instance d'une manière logiquement compatible.

Deux listes avec le même contenu sont toujours des objets différents et produiront des codes de hachage différents. Puisque nous voulons que ces deux listes soient traitées comme égales, nous devons laisser GetHashCodeproduire la même valeur pour chacune d'elles. Nous pouvons accomplir cela en déléguant le code de hachage à chaque élément de la liste et en utilisant le XOR au niveau du bit standard pour les combiner tous. XOR est indépendant de l'ordre, donc peu importe si les listes sont triées différemment. Il importe seulement qu'ils ne contiennent que des membres équivalents.

Remarque: le nom étrange signifie que la méthode ne prend pas en compte l'ordre des éléments dans la liste. Si vous vous souciez de l'ordre des éléments dans la liste, cette méthode n'est pas pour vous!

J'ai utilisé ce code pour comparer deux listes contenant des millions d'enregistrements.

Cette méthode ne prendra pas beaucoup de temps

    //Method to compare two list of string
    private List<string> Contains(List<string> list1, List<string> list2)
    {
        List<string> result = new List<string>();

        result.AddRange(list1.Except(list2, StringComparer.OrdinalIgnoreCase));
        result.AddRange(list2.Except(list1, StringComparer.OrdinalIgnoreCase));

        return result;
    }

Si seul un résultat combiné est nécessaire, cela fonctionnera aussi:

var set1 = new HashSet<T>(list1);
var set2 = new HashSet<T>(list2);
var areEqual = set1.SetEquals(set2);

où T est le type d'élément de listes.

C'est peut-être drôle, mais ça marche pour moi

string.Join ("", List1)! = string.Join ("", List2)

Je pense que c'est un moyen simple et facile de comparer deux listes élément par élément

x=[1,2,3,5,4,8,7,11,12,45,96,25]
y=[2,4,5,6,8,7,88,9,6,55,44,23]

tmp = []


for i in range(len(x)) and range(len(y)):
    if x[i]>y[i]:
        tmp.append(1)
    else:
        tmp.append(0)
print(tmp)

C'est la meilleure solution que vous ayez trouvée

var list3 = list1.Where(l => list2.ToList().Contains(l));