Linq To Entities बनाम Linq ऑब्जेक्ट्स को समूहीकरण के उदाहरण के रूप में

LINQ एक आरामदायक, सुंदर, लेकिन एक ही समय में कपटी नहीं है। LINQ और LINQ ऑब्जेक्ट्स के कुछ कार्यान्वयन के जंक्शन पर आमतौर पर सबसे अप्रत्याशित चीजें होती हैं। आज, एक उदाहरण के साथ, मैं LINQ To Entities (Entity Framework) और LINQ To Objects का सहयोग देखूंगा।



चलो एक इनपुट के रूप में रिपॉजिटरी विधि लेते हैं, जो एक इनपुट के रूप में ग्राहक पहचानकर्ताओं की एक सूची लेता है और इन पहचानकर्ताओं द्वारा वर्गीकृत आदेशों का एक सेट लौटाता है (आदेश तालिका में फ़ील्ड्स ऑर्डरआईडी, ऑर्डरडेट और कस्टमआईड शामिल हैं):

public IDictionary<long, List<Order>> GetOrdersByCustomersIds(IList<long> customersIds) { using (var ctx = new RepositoryContext()) { return ctx.Orders. Where(o => customersIds.Contains(o.Id)). GroupBy(o => o.CustomerId). ToDictionary(o => o.Key, o => o.ToList()); } } 

एक मिनट रुको! यह कैसे काम करता है? दरअसल, ग्रुप बाय बाय को निष्पादित करते समय, हम केवल उन फ़ील्ड्स का चयन कर सकते हैं जिनके द्वारा ग्रुपिंग होती है, साथ ही एग्रीगेटेड वैल्यूज़ भी। इस समस्या का मानक समाधान तालिका डेटा और समूहीकरण परिणामों का एक JOIN है। कुछ इस तरह:

  SELECT o1.*, MinTotal FROM Orders as o1 INNER JOIN (SELECT o2.CustomerId, Min(o2.Total) as MinTotal FROM Orders o2 GROUP BY o2.CustomerId) as o3 ON o1.CustomerId = o3.CustomerId Where o1.CustomerId in (1, 2, 3, 4, 5) 

ईएफ प्रदाता द्वारा ऐसा कुछ उत्पन्न किया जाना चाहिए। चलो यह सुनिश्चित करते हैं। मेरे पास हाथ में MySQL .NET कनेक्टर (MySQL के लिए आधिकारिक ADO.NET प्रदाता) था, इसलिए मैंने इसका लाभ उठाया और निम्नलिखित उत्पन्न अनुरोध प्राप्त किया (इनपुट के रूप में 1 से 5 तक पहचानकर्ताओं की सूची पारित करना):

 SELECT `Project2`.`C1`, `Project2`.`CustomerId`, `Project2`.`C2`, `Project2`.`CustomerId1`, `Project2`.`Id`, `Project2`.`OrderDate` FROM (SELECT `Distinct1`.`CustomerId`, 1 AS `C1`, `Extent2`.`CustomerId` AS `CustomerId1`, `Extent2`.`Id`, `Extent2`.`OrderDate`, CASE WHEN (`Extent2`.`CustomerId` IS NULL) THEN (NULL) ELSE (1) END AS `C2` FROM (SELECT DISTINCT `Extent1`.`CustomerId` FROM `orders` AS `Extent1` WHERE ((1 = `Extent1`.`Id`) OR (2 = `Extent1`.`Id`)) OR (((3 = `Extent1`.`Id`) OR (4 = `Extent1`.`Id`)) OR (5 = `Extent1`.`Id`))) AS `Distinct1` LEFT OUTER JOIN `orders` AS `Extent2` ON (((1 = `Extent2`.`Id`) OR (2 = `Extent2`.`Id`)) OR (((3 = `Extent2`.`Id`) OR (4 = `Extent2`.`Id`)) OR (5 = `Extent2`.`Id`))) AND (`Distinct1`.`CustomerId` = `Extent2`.`CustomerId`)) AS `Project2` ORDER BY `CustomerId` ASC, `C2` ASC 

मैनुअल कार्यान्वयन थोड़ा खराब है, लेकिन पूरे पर, ऊपर सोचा गया आवाज का पता लगाया जा सकता है।

इसे रोको! हम डेटाबेस स्तर पर समूहीकरण का उपयोग क्यों करते हैं? समूहीकरण उचित है अगर एकत्रीकरण कार्यों का उपयोग किया जाता है (जैसा कि क्वेरी के उपरोक्त मैनुअल कार्यान्वयन में है)। हमारे मामले में, समूहीकरण केवल प्राप्त आंकड़ों का एक सुविधाजनक प्रतिनिधित्व है। चलो रिपॉजिटरी विधि को थोड़ा संशोधित करते हैं और समूहन प्रक्रिया को LINQ को ऑब्जेक्ट स्तर पर स्थानांतरित करते हैं:

 public IDictionary<long, List<Order>> GetOrdersByCustomersIds(IList<long> customersIds) { using (var ctx = new RepositoryContext()) { return ctx.Orders. Where(o => customersIds.Contains(o.Id)). AsEnumerable(). GroupBy(o => o.CustomerId). ToDictionary(o => o.Key, o => o.ToList()); } } 

चित्र को पूरा करने के लिए, आइए देखें कि ईएफ प्रदाता क्या अनुरोध उत्पन्न करेगा:

 SELECT `Extent1`.`CustomerId`, `Extent1`.`Id`, `Extent1`.`OrderDate` FROM `orders` AS `Extent1` WHERE ((1 = `Extent1`.`Id`) OR (2 = `Extent1`.`Id`)) OR (((3 = `Extent1`.`Id`) OR (4 = `Extent1`.`Id`)) OR (5 = `Extent1`.`Id`)) 

निश्चित रूप से यह क्वेरी पिछले वाले की तुलना में अधिक कुशल है।

वह, वास्तव में, सब है। कुछ खास नहीं - मैं सिर्फ आपका ध्यान इस जाल में पड़ने के बाद LINQ To X से LINQ तक की वस्तुओं पर आपका ध्यान आकर्षित करना चाहता था। सतर्क रहो!

PS इस तथ्य के बावजूद कि मैंने MySQL .NET कनेक्टर का उपयोग किया है, मैं स्पष्ट रूप से उत्पादन में इस प्रदाता का उपयोग करने की अनुशंसा नहीं करता हूं: यह एक प्रदाता नहीं है, लेकिन बग का एक केंद्रित गुच्छा है जो वर्षों तक नहीं रहेगा।