Comparer la liste dans LINQ et renvoyer 2 objets de résultat

Vous pouvez créer un IEqualityComparer personnalisé :

var present = newCars.Intersect(oldCars, new CarEqualityComparer());
var absent = newCars.Except(oldCars, new CarEqualityComparer());

Et l'utiliser comme ceci:

public class CarEqualityComparer : IEqualityComparer<Car>
{
    public bool Equals(Car x, Car y)
    {
        return x.Id == y.Id;
    }

    public int GetHashCode(Car obj)
    {
        return obj.Id.GetHashCode();
    }
}

Vous pouvez utiliser une variable anonyme contenant les deux listes:

var res = new
{
    present = newCars.Where(n => oldCars.Select(o => o.Id).Contains(n.Id)), // present if the old cars list contains the id from the new list
    absent = newCars.Where(n => !oldCars.Select(o => o.Id).Contains(n.Id)) // absent if the old cars list does not contain the id from the new list
};

Lorsque vous dites que les nouvelles voitures sont la source de la vérité, cela signifie que vous les voulez toujours dans la liste, mais que vous n'avez peut-être pas une vieille voiture équivalente. Vous décrivez une jointure à gauche.

Cela devrait vous donner la plupart de ce que vous voulez.

var finalResult = (Present: results[0], Absent: results[1]);

Le résultat est un tuple contenant la nouvelle voiture et un Présentez qui est true ou false selon qu'il y a une vieille voiture ou non.

Cela vous donne un seul ensemble de résultats . Vous vouliez deux ensembles de résultats sous forme de tuple. Pour obtenir cela, étendez simplement la requête ci-dessus, en regroupant par Présent . Cela vous donne un ensemble de résultats avec exactement deux éléments

var results = (from r in (from n in newCars
        join o in oldCars
        on n.Id equals o.Id
        into cars
        from oc in cars.DefaultIfEmpty()
        select (NewCar: n, Present: oc != null))
    group r by r.Present into g
    orderby g.Key descending 
    select g.Select(x => x.NewCar).ToList()).ToList();

à partir desquels vous pouvez obtenir un seul tuple contenant les deux listes

var results = from n in newCars
    join o in oldCars
    on n.Id == o.Id
    group into cars 
    from oc in cars.DefaultIfEmpty()
    select (NewCar: n, Present: oc != null)

p>

En utilisant une méthode d'extension pour traiter l'ajout à une liste (un tout petit peu) de manière plus fonctionnelle, vous pouvez utiliser LINQ Aggregate pour le faire en un seul passage:

    var idsFromOldCars = oldCars.Select(c => c.Id).ToHashSet();
    var present = new List<Car>();
    var absent = new List<Car>();
    foreach (var nc in newCars) {
        if (idsFromOldCars.Contains(nc.Id))
            present.Add(nc);
        else
            absent.Add(nc);
    }

Où AfterAdd est défini dans une classe statique comme:

public static class ListExt {
    public static List<T> AfterAdd<T>(this List<T> head, params T[] tail) {
        head.AddRange(tail);
        return head;
    }
}

Mais il est beaucoup plus clair d'utiliser simplement un foreach boucle:

var idsFromOldCars = oldCars.Select(c => c.Id).ToHashSet();
var(present, absent) = newCars.Aggregate((p:new List<Car>(),a:new List<Car>()), (pa,nc) => idsFromOldCars.Contains(nc.Id) ? (pa.p.AfterAdd(nc),pa.a) : (pa.p,pa.a.AfterAdd(nc)));

Dans les deux cas, la création du HashSet garantit que vous n'avez pas à parcourir la liste oldCars pour trouver chaque newCar . Si vous saviez que les listes étaient classées par Id , vous pourriez faire une solution en un seul passage plus compliquée en parcourant les listes en parallèle, mais cela ne semble même pas valoir la complexité.

REMARQUE: Une Rejoindre fait effectivement quelque chose de similaire, en convertissant la deuxième Liste en une Recherche (comme un Dictionnaire ) qui peut être utilisé pour trouver les correspondances avec la première List.