c# - LINQ-बाएं शामिल हों, समूह द्वारा, और गणना करें





.net linq-to-sql (5)


देर से जवाब:

यदि आप जो भी कर रहे हैं, तो आपको बाएं शामिल होने की आवश्यकता नहीं है, गणना करें ()। ध्यान दें कि join...into लिए वास्तव में GroupJoin में अनुवाद किया join...into है जो समूह को new{parent,IEnumerable<child>} जैसे लौटाता है ताकि आपको समूह पर Count() को कॉल करने की आवश्यकता हो:

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

एक्सटेंशन विधि सिंटैक्स में join into GroupJoin समतुल्य है (जबकि बिना किसी GroupJoin into Join ):

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

मान लें कि मेरे पास यह एसक्यूएल है:

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

मैं LINQ से SQL में इसका अनुवाद कैसे कर सकता हूं? मैं COUNT (c.ChildId) पर फंस गया, जेनरेटेड एसक्यूएल हमेशा COUNT (*) आउटपुट प्रतीत होता है। यहां तक ​​कि मुझे अब तक क्या मिला है:

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

धन्यवाद!




एक सबक्वायरी का उपयोग करने पर विचार करें:

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 } ;

यदि क्वेरी प्रकार किसी एसोसिएशन से जुड़े होते हैं, तो यह सरल होता है:

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



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(t=>t.ChildId != null) }



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



उस लेख में उल्लिखित कई स्पष्ट मतभेद हैं @lars पोस्ट किया गया है, लेकिन संक्षिप्त जवाब है:

  • एल 2 एस कसकर युग्मित है - डेटाबेस के विशिष्ट क्षेत्र में ऑब्जेक्ट प्रॉपर्टी या एक विशिष्ट डेटाबेस स्कीमा पर मैपिंग का सही ढंग से ऑब्जेक्ट करें
  • एल 2 एस केवल SQL सर्वर के साथ काम करेगा (जहां तक ​​मुझे पता है)
  • ईएफ एक वर्ग को कई तालिकाओं में मैप करने की अनुमति देता है
  • ईएफ एमएम संबंधों को संभालेगा
  • ईएफ में किसी भी ADO.NET डेटा प्रदाता को लक्षित करने की क्षमता होगी

मूल आधार एल 2 एस रैपिड डेवलपमेंट के लिए है, और अधिक "एंटरप्राइज़" एन-स्तरीय अनुप्रयोगों के लिए ईएफ है, लेकिन यह एल 2 एस को थोड़ा छोटा बेच रहा है।





c# .net linq linq-to-sql