Linq to entities rejoindre vs groupjoin

Question

J'ai web cherché mais je ne trouve pas de réponse simple. Quelqu'un peut-il expliquer (en anglais) ce qu'est un groupjoin est? Comment est-il différent à partir d'une jointure interne? Il est couramment utilisé? Est-il seulement pour la méthode de la syntaxe? Ce à propos de la syntaxe de la requête? Un exemple de code c#, ce serait bien.

Answer 1

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 l' Id domaine le résultat sera:

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

Lorsque vous GroupJoin les deux listes sur l' Id domaine 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 la jointure interne en SQL: il n'y a pas d'entrées pour C. Alors qu' GroupJoin est l'équivalent de la jointure externe: 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).

Modifier C'était une façon de souligner les différences de manière globale, parce que la recherche dans la syntaxe directement est toujours un peu déroutant. Mais la syntaxe et les valeurs de retour ne peut pas être ignoré.

Alors laissez les deux listes d' IEnumerable<Parent> et IEnumerable<Child> respectivement. (En cas de linq pour les entités: IQueryale).

Join de la 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 utilise l' Join méthode sous le capot.

GroupJoin de la 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 utilise l' 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.

Answer 2

Selon eduLINQ:

La meilleure façon de se familiariser avec ce GroupJoin n'est de penser à Rejoignez. Là, l'idée générale est que nous avons regardé à travers l ' "extérieur" la séquence d'entrée, trouvé tous les éléments correspondants de la "intérieure" de la séquence (selon une clé de projection sur chaque séquence) et puis a donné des paires de les éléments correspondants. GroupJoin est similaire, sauf qu'au lieu de produisant des paires d'éléments, elle donne un résultat unique pour chaque "extérieure" élément sur ce point, et la séquence de correspondance "intérieure" des éléments.

La seule différence est dans l'instruction de retour:

Joindre:

var lookup = inner.ToLookup(innerKeySelector, comparer); 
foreach (var outerElement in outer) 
{ 
    var key = outerKeySelector(outerElement); 
    foreach (var innerElement in lookup[key]) 
    { 
        yield return resultSelector(outerElement, innerElement); 
    } 
} 

GroupJoin:

var lookup = inner.ToLookup(innerKeySelector, comparer); 
foreach (var outerElement in outer) 
{ 
    var key = outerKeySelector(outerElement); 
    yield return resultSelector(outerElement, lookup[key]); 
} 

Lire la suite ici:

• Réimplanter LINQ to Objects: Partie 19 - Rejoindre

• Réimplanter LINQ to Objects: Partie 22 - GroupJoin