LINQ - Jointure gauche, Grouper par et Compter

Question

Disons que j'ai cette instruction SQL :

SELECT p.ParentId, COUNT(c.ChildId)
FROM ParentTable p
  LEFT OUTER JOIN ChildTable c ON p.ParentId = c.ChildParentId
GROUP BY p.ParentId

Comment puis-je traduire cela en LINQ to SQL ? Je suis bloqué sur le COUNT(c.ChildId), le SQL généré semble toujours produire COUNT(*). Voici ce que j'ai jusqu'à présent :

from p in context.ParentTable
join c in context.ChildTable on p.ParentId equals c.ChildParentId into j1
from j2 in j1.DefaultIfEmpty()
group j2 by p.ParentId into grouped
select new { ParentId = grouped.Key, Count = grouped.Count() }

Merci !

Answer 1

de p in context.ParentTable
joindre c dans le contexte.ChildTable on p.ParentId équivaut à c.ChildParentId dans j1 
de j2 dans j1.DefaultIfEmpty()
regrouper j2 par p.ParentId dans regroupé
sélectionner new { ParentId = regroupé.Key, Count = regroupé.Count(t=>t.ChildId != null) }

Answer 2

Considérez l'utilisation d'une sous-requête :

from p in context.ParentTable 
let cCount =
(
  from c in context.ChildTable
  where p.ParentId == c.ChildParentId
  select c
).Count()
select new { ParentId = p.Key, Count = cCount } ;

---

Si les types de requête sont connectés par une association, cela se simplifie à :

from p in context.ParentTable 
let cCount = p.Children.Count()
select new { ParentId = p.Key, Count = cCount } ;

Answer 3

RÉPONSE TARDIVE:

Vous ne devriez pas avoir besoin de la jointure gauche du tout si tout ce que vous faites est Count(). Notez que join...into est en fait traduit en GroupJoin qui renvoie des regroupements comme new{parent,IEnumerable} donc vous devez simplement appeler Count() sur le groupe:

from p in context.ParentTable
join c in context.ChildTable on p.ParentId equals c.ChildParentId into g
select new { ParentId = p.Id, Count = g.Count() }

Dans la syntaxe de méthode d'extension, un join into est équivalent à GroupJoin (tandis qu'un join sans un into est Join):

context.ParentTable
    .GroupJoin(
                   inner: context.ChildTable
        outerKeySelector: parent => parent.ParentId,
        innerKeySelector: child => child.ParentId,
          resultSelector: (parent, children) => new { parent.Id, Count = children.Count() }
    );

Answer 4

 (from p in context.ParentTable     
  join c in context.ChildTable 
    on p.ParentId equals c.ChildParentId into j1 
  from j2 in j1.DefaultIfEmpty() 
     select new { 
          ParentId = p.ParentId,
         ChildId = j2==null? 0 : 1 
      })
   .GroupBy(o=>o.ParentId) 
   .Select(o=>new { ParentId = o.key, Count = o.Sum(p=>p.ChildId) })

Answer 5

Alors que l'idée derrière la syntaxe LINQ vise à émuler la syntaxe SQL, vous ne devriez pas toujours penser à traduire directement votre code SQL en LINQ. Dans ce cas particulier, nous n'avons pas besoin de faire un group into puisque join into est en soi un group join.

Voici ma solution:

from p in context.ParentTable
join c in context.ChildTable on p.ParentId equals c.ChildParentId into joined
select new { ParentId = p.ParentId, Count = joined.Count() }

Contrairement à la solution la plus votée ici, nous n'avons pas besoin de j1, j2 et de vérification de null dans Count(t => t.ChildId != null)