Le moyen le plus rapide pour comparer deux Liste<>

Utilisation Sauf:

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

Je soupçonne qu'il y a des approches qui serait en réalité légèrement plus rapide que ça, mais même ce sera très plus vite que votre O(N * M) approche.

Si vous voulez combiner ces, vous pouvez créer une méthode avec le ci-dessus, puis une instruction de retour:

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

Si vous voulez que les résultats soient casse, le travail:

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();

firstNotSecond contiendrait b1.dll

secondNotFirst contiendrait b2.dll

essayer 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, vous avez seulement besoin de savoir si deux listes sont différentes, et pas en quoi consistent ces différences. Dans ce cas, envisager l'ajout de cette méthode d'extension pour votre projet. Notez que vos objets répertoriés devrait mettre en œuvre IEquatable!

Utilisation:

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
}

Quel que soit le Component classe, les méthodes indiquées ici pour Car devrait être mis en œuvre de manière quasiment identique.

Il est très important de noter la façon dont nous l'avons écrit GetHashCode. Afin de mettre en œuvre correctement IEquatable, Equals et GetHashCode doit fonctionner sur l'instance de propriétés dans une logique de compatibilité.

Deux listes avec le même contenu sont toujours différents objets, et de produire différents codes de hachage. Puisque nous voulons que ces deux listes à être traités comme des égaux, nous devons laisser les GetHashCode produire la même valeur pour chacun d'eux. Nous pouvons réaliser cela en déléguant le hashcode de chaque élément dans la liste, et à l'aide de la norme XOR au niveau du bit pour les combiner. XOR est de l'ordre indépendant, de sorte qu'il n'a pas d'importance si les listes sont triées de manière différente. Il importe seulement qu'ils ne contiennent que de l'équivalent de membres.

Remarque: le nom étrange est d'impliquer le fait que la méthode ne considère pas l'ordre des éléments dans la liste. Si vous ne vous souciez de l'ordre des éléments dans la liste, cette méthode n'est pas pour vous!

Si seulement résultat combiné de besoin, ce sera trop de travail:

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

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

C'est la meilleure solution que vous aurez trouvé

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