Linq प्रक्षेपण

Question

मैं एक गणनीय सूची है कि एक चपटी माता पिता के बच्चे का रिश्ता शामिल है:

ParentGuid1, ParentName1, ChildGuid1, ChildName1 
ParentGuid1, ParentName1, ChildGuid2, ChildName2 
ParentGuid2, ParentName2, ChildGuid3, ChildName3 
ParentGuid2, ParentName2, ChildGuid4, ChildName4 

मैं एक बच्चे की कक्षा के लिए और माता पिता के वर्ग है कि एक List<Child> संपत्ति भी शामिल है परिभाषित किया है बच्चों को बुलाया

क्या मैं उस अभिभावक से जुड़े बच्चों द्वारा एकत्रित सूची का संदर्भ देने के लिए अभिभावक वर्ग प्रति अद्वितीय अभिभावक के एक उदाहरण के साथ ऑब्जेक्ट ग्राफ़ पर बनाने के लिए linq का उपयोग कर सकता हूं।

इस की तर्ज पर

कुछ (ध्यान दें, इस कोड संकलन नहीं करता है):

myFlattenedHierarchy.Select(p => new Parent 
    {Guid = p.ParentGuid, 
    Name = p.ParentName, 
    Children = myFlattenedHierarchy.Where(c => c.ParentGuid == p.ParentGuid).Select(c => new Child{Guid = c.ChildGuid, Name = c.ChildName}) 
    }); 

Answer 1

myFlattenedHierarchy.Select(p => new Parent 
    {Guid = p.ParentGuid, 
    Name = p.ParentName, 
    Children = myFlattenedHierarchy.Where(c => c.ParentGuid == p.ParentGuid).Select(c => new Child{Guid = c.ChildGuid, Name = c.ChildName}) 
    }); 

आपको लगता है कि ऐसा करने में सक्षम होना चाहिए, लेकिन Children एक सूची नहीं किया जा सकता है, यह IEnumerable हो गया है।

Answer 2

मेरा मानना ​​है कि आप GroupBy() (पूर्ण प्रकटीकरण: संकलित नहीं): उपयोग कर सकते हैं

myFlattenedHierarchy.GroupBy(row => row.ParentGuid) 
    .Select(group => new Parent 
     { 
      Guid = group.Key.ParentGuid, 
      Name = group.Key.ParentName, 
      Children = myFlattenedHierarchy.Where(c => c.ParentGuid == group.Key.ParentGuid) 
       .Select(c => new Child{ Guid = c.ChildGuid, Name = c.ChildName }) 
       .ToList() 
     }); 

Answer 3

यदि आपके फ्लैट संग्रह में से एक लूप है तो आपको रिकर्सिविटी और अनंत रिकर्सिविटी से निपटने की आवश्यकता है। लिंक को पूरी समस्या के लिए उपयोग नहीं किया जा सकता है लेकिन एक विशिष्ट नोड के बच्चे को वापस करने में मदद कर सकता है।

Answer 4

यहां एक सरल लूप के साथ ऐसा करने के लिए पूर्व-लिंक तरीका है।

Dictionary<Guid, Parent> parents = new Dictionary<Guid, Parent>(); 
foreach(RowType row in myFlattenedHierarchy) //just enumerate once 
{ 
    if (!parents.ContainsKey(row.ParentGuid) 
    { 
    Parent newParent = new Parent(row); 
    parents[row.ParentGuid] = newParent; 
    } 

    Child newChild = new Child(row); 

    Parent theParent = parents[row.ParentGuid]; 
    theParent.Children.Add(newChild); 
} 

List<Parent> result = parents.Values.ToList(); 

---

या आप GroupBy का प्रयोग कर एक समान परिणाम प्राप्त करने के सकता है।

from row in myFlattenedHierarchy 
group row by row.ParentGuid into g 
select new Parent() 
{ 
    Guid = g.Key, 
    Name = g.First().ParentName, 
    Children = 
    (
    from childRow in g 
    select new Child() 
    { 
     Guid = childrow.ChildGuid, 
     Name = childrow.ChildName 
    } 
).ToList() 
} 

यह एक टॉस-अप है जो अधिक रखरखाव योग्य है। किसी भी तरह से, लूप/क्वेरी के अंदर myFlattenedHierarchy को फिर से गणना न करें।

Answer 5

यह काम करना चाहिए, डेविड बी के दूसरे उदाहरण के समान ही काम करना चाहिए, लेकिन मैं बिना किसी फिक्सिंग (एकाधिक कॉलम द्वारा समूहबद्ध) के बिना काम नहीं कर सका, इसलिए मैंने इसे रिकॉर्ड के लिए यहां जोड़ा है।

from row in myFlattenedHierarchy 
group row by new { row.ParentGuid, row.ParentName } into g 
select new Parent() 
{ 
    Guid = g.Key.ParentGuid, 
    Name = g.Key.ParentName, 
    Children = 
    (
    from childRow in g 
    select new Child() 
    { 
     Guid = childRow.ChildGuid, 
     Name = childRow.ChildName 
    } 
).ToList() 
};