Linq to entities rejoindre vs groupjoin

Comportement

Supposons que vous avez deux listes:

Id  Value
1   A
2   B
3   C

Id  ChildValue
1   a1
1   a2
1   a3
2   b1
2   b2

Lorsque vous Join les deux listes sur le Id champ, le résultat sera:

Value ChildValue
A     a1
A     a2
A     a3
B     b1
B     b2

Lorsque vous GroupJoin les deux listes sur le Id champ, le résultat sera:

Value  ChildValues
A      [a1, a2, a3]
B      [b1, b2]
C      []

Donc Join produit d'une télévision (tabulaire) résultat de parent et de l'enfant les valeurs.

GroupJoin produit une liste d'entrées dans la première liste, chacun avec un groupe d'entrées jointes dans la deuxième liste.

C'est pourquoi Join est l'équivalent de INNER JOIN en SQL: il n'y a pas d'entrées pour C. Alors que GroupJoin est l'équivalent de OUTER JOIN: C est dans le jeu de résultats, mais avec une liste vide d'entrées connexes (dans un SQL ensemble de résultats, il y aurait une ligne C - null).

Syntaxe

Alors laissez les deux listes sont IEnumerable<Parent> et IEnumerable<Child> respectivement. (En cas de Linq to entities: IQueryable<T>).

Join syntaxe serait

from p in Parent
join c in Child on p.Id equals c.Id
select new { p.Value, c.ChildValue }

retour d'un IEnumerable<X> où X est un type anonyme avec deux propriétés, Value et ChildValue. Cette syntaxe de requête utilise la Join méthode sous le capot.

GroupJoin syntaxe serait

from p in Parent
join c in Child on p.Id equals c.Id into g
select new { Parent = p, Children = g }

retour d'un IEnumerable<Y> où Y est un type anonyme constituée d'une propriété de type Parent et une propriété de type IEnumerable<Child>. Cette syntaxe de requête utilise la GroupJoin méthode sous le capot.

Nous pouvons juste faire select g dans la dernière question, qui serait de sélectionner un IEnumerable<IEnumerable<Child>>, dire une liste de listes. Dans de nombreux cas, la sélectionner avec le parent inclus est plus utile.

Certains cas d'utilisation

1. La production d'un plat de jointure externe.

Comme l'a dit, la déclaration ...

from p in Parent
join c in Child on p.Id equals c.Id into g
select new { Parent = p, Children = g }

... produit une liste de parents avec les groupes d'enfants. Cela peut être transformé en une liste à plat de parent-enfant paires par deux petits ajouts:

from p in parents
join c in children on p.Id equals c.Id into g //<= into
from c in g.DefaultIfEmpty()               //<= flattens the groups
select new { Parent = p.Value, Child = c?.ChildValue }

Le résultat est similaire à

Value Child
A     a1
A     a2
A     a3
B     b1
B     b2
C     (null)

Noter que le variable de portée c est réutilisé dans la déclaration ci-dessus. Ce faisant, tout join instruction peut simplement être converti en outer join en ajoutant l'équivalent de into g from c in g.DefaultIfEmpty() à un join déclaration.

C'est là que la requête (ou complète) de la syntaxe brille. Méthode (ou fluide) syntaxe montre ce qui se passe vraiment, mais il est difficile d'écrire:

parents.GroupJoin(children, p => p.Id, c => c.Id, (p, c) => new { p, c })
       .SelectMany(x => x.c.DefaultIfEmpty(), (x,c) => new { x.p.Value, c?.ChildValue } )

Donc un plat outer join dans LINQ est un GroupJoin, aplatie par SelectMany.

2. Le maintien de l'ordre

Supposons que la liste des parents est un peu plus long. Une INTERFACE utilisateur produit une liste de parents sélectionnés comme Id valeurs dans un ordre fixe. Nous allons utiliser:

var ids = new[] { 3,7,2,4 };

Maintenant, les parents sélectionnés doivent être filtrées par les parents liste dans l'ordre exact.

Si nous ne ...

var result = parents.Where(p => ids.Contains(p.Id));

... l'ordre de parents déterminera le résultat. Si les parents sont commandés par Id, le résultat sera parents, 2, 3, 4, 7. Pas bonne. Cependant, nous pouvons également utiliser join pour filtrer la liste. Et en utilisant ids comme première liste, la commande sera conservée:

from id in ids
join p in parents on id equals p.Id
select p

Le résultat est que les parents de 3, 7, 2, 4.