मेमने का उपयोग कर कई कॉलम के साथ समूह

Question

मैं मेमने का उपयोग करके कई कॉलमों के साथ समूह कैसे बना सकता हूं?

मैंने देखा कि इसे संस्थाओं को लाइनक का उपयोग कैसे करना है, लेकिन मैं लैंबडा फॉर्म की तलाश कर रहा हूं।

Answer 1

var query = source.GroupBy(x => new { x.Column1, x.Column2 });

Comments

क्या यह वास्तव में काम करेगा? मुझे लगता है कि आपके द्वारा समूहीकृत की जाने वाली प्रत्येक वस्तु के लिए समानता परीक्षण विफल हो जाएगा क्योंकि वे वस्तुएं हैं और संरचना नहीं।

— याकूब

@ अडूसी: धन्यवाद। क्या आप उदाहरण दे सकते हैं कि मैं समूह आइटम का IEnumerable कैसे प्राप्त कर सकता हूं?

— नोर

@ जेकॉब - बेनामी प्रकार ठीक से ओवरराइड GetHashCodeऔर Equalsविधियों के साथ अपरिवर्तनीय वर्ग हैं । वे जहां इस तरह के उपयोग के मामले के लिए डिज़ाइन किए गए हैं।

— Enigmativity

@ नोर - GroupByएक रिटर्न है IEnumerable<IGrouping<TKey, TSource>>जो अनिवार्य रूप से आंतरिक संपत्ति पर IEnumerable<IEnumerable<TSource>>एक Keyसंपत्ति के साथ है । क्या यह आपको समूह आइटम के "IEnumerable" प्राप्त करने में मदद करता है?

— Enigmativity

अगर मेरा 'सोर्स' वेरिएबल डिक्शनरी कलेक्शन है तो यह काम नहीं करता। सुझाव?

— जोआओ पाउलो

Answer 2

अगर आपकी टेबल इस तरह है

rowId     col1    col2    col3    col4
 1          a       e       12       2
 2          b       f       42       5
 3          a       e       32       2
 4          b       f       44       5


var grouped = myTable.AsEnumerable().GroupBy(r=> new {pp1 =  r.Field<int>("col1"), pp2 = r.Field<int>("col2")});

Comments

यह ध्यान रखना बहुत महत्वपूर्ण है कि AsEnumerable समूहीकरण से पहले पूरी तालिका को स्मृति में लाएगा। यह निश्चित रूप से कुछ तालिकाओं पर मायने रखता है। अधिक जानकारी के लिए यह उत्तर देखें: stackoverflow.com/questions/17968469/…

— ब्रैंडन बार्कले

Answer 3

इसके बाद के संस्करण का उत्तर देने के लिए आगे - यदि आपको कुंजी द्वारा उन समूह के आधार पर फ़िल्टर करने की आवश्यकता है, तो आप कई कुंजियों को लपेटने के लिए एक वर्ग को परिभाषित कर सकते हैं।

return customers.GroupBy(a => new CustomerGroupingKey(a.Country, a.Gender))
                .Where(a => a.Key.Country == "Ireland" && a.Key.Gender == "M")
                .SelectMany(a => a)
                .ToList();

जहां CustomerGroupingKey समूह कुंजी लेता है:

    private class CustomerGroupingKey
    {
        public CustomerGroupingKey(string country, string gender)
        {
            Country = country;
            Gender = gender;
        }

        public string Country { get; }

        public string Gender { get; }
    }

Comments

संभवतः किसी को कुछ समय बचा लेगा: ऑब्जेक्ट आरंभीकरण के साथ डिफ़ॉल्ट निर्माण का उपयोग करना बेहतर है। ऊपर दिए गए नमूना कोड में दृष्टिकोण को ईएफ कोर की तरह ओआरएम द्वारा इलाज नहीं किया जाएगा ।

— कॉन्सटेंटिन

Answer 4

     class Element
        {
            public string Company;        
            public string TypeOfInvestment;
            public decimal Worth;
        }

   class Program
    {
        static void Main(string[] args)
        {
         List<Element> elements = new List<Element>()
            {
                new Element { Company = "JPMORGAN CHASE",TypeOfInvestment = "Stocks", Worth = 96983 },
                new Element { Company = "AMER TOWER CORP",TypeOfInvestment = "Securities", Worth = 17141 },
                new Element { Company = "ORACLE CORP",TypeOfInvestment = "Assets", Worth = 59372 },
                new Element { Company = "PEPSICO INC",TypeOfInvestment = "Assets", Worth = 26516 },
                new Element { Company = "PROCTER & GAMBL",TypeOfInvestment = "Stocks", Worth = 387050 },
                new Element { Company = "QUASLCOMM INC",TypeOfInvestment = "Bonds", Worth = 196811 },
                new Element { Company = "UTD TECHS CORP",TypeOfInvestment = "Bonds", Worth = 257429 },
                new Element { Company = "WELLS FARGO-NEW",TypeOfInvestment = "Bank Account", Worth = 106600 },
                new Element { Company = "FEDEX CORP",TypeOfInvestment = "Stocks", Worth = 103955 },
                new Element { Company = "CVS CAREMARK CP",TypeOfInvestment = "Securities", Worth = 171048 },
            };

            //Group by on multiple column in LINQ (Query Method)
            var query = from e in elements
                        group e by new{e.TypeOfInvestment,e.Company} into eg
                        select new {eg.Key.TypeOfInvestment, eg.Key.Company, Points = eg.Sum(rl => rl.Worth)};



            foreach (var item in query)
            {
                Console.WriteLine(item.TypeOfInvestment.PadRight(20) + " " + item.Points.ToString());
            }


            //Group by on multiple column in LINQ (Lambda Method)
            var CompanyDetails =elements.GroupBy(s => new { s.Company, s.TypeOfInvestment})
                               .Select(g =>
                                            new
                                            {
                                                company = g.Key.Company,
                                                TypeOfInvestment = g.Key.TypeOfInvestment,            
                                                Balance = g.Sum(x => Math.Round(Convert.ToDecimal(x.Worth), 2)),
                                            }
                                      );
            foreach (var item in CompanyDetails)
            {
                Console.WriteLine(item.TypeOfInvestment.PadRight(20) + " " + item.Balance.ToString());
            }
            Console.ReadLine();

        }
    }

Answer 5

मैं डेविड के जवाब की तरह एक वर्ग को परिभाषित करने के मिश्रण के साथ आया था, लेकिन इसके साथ जाने के लिए कहां कक्षा की आवश्यकता नहीं थी। यह कुछ इस तरह दिखता है:

var resultsGroupings = resultsRecords.GroupBy(r => new { r.IdObj1, r.IdObj2, r.IdObj3})
                                    .Select(r => new ResultGrouping {
                                        IdObj1= r.Key.IdObj1,
                                        IdObj2= r.Key.IdObj2,
                                        IdObj3= r.Key.IdObj3,
                                        Results = r.ToArray(),
                                        Count = r.Count()
                                    });



private class ResultGrouping
        {
            public short IdObj1{ get; set; }
            public short IdObj2{ get; set; }
            public int IdObj3{ get; set; }

            public ResultCsvImport[] Results { get; set; }
            public int Count { get; set; }
        }

resultRecordsमेरी प्रारंभिक सूची मैं कहां समूह बना रहा हूं, और इसके ए List<ResultCsvImport>। ध्यान दें कि यहाँ विचार यह है कि, मैं 3 कॉलम, IdObj1 और IdObj2 और Idbb3 द्वारा समूहीकरण कर रहा हूँ