नेस्टेड क्लास सूची <T> से एक फ़्लैटेड सूची कैसे प्राप्त करें?

Question

मेरे पास question using these same examples है - यह प्रश्न एक अलग मुद्दे पर केंद्रित है। को देखते हुए निम्नलिखित वर्गों:

[XmlRoot] 
    public class Family { 

     [XmlElement] 
     public List<Person> Person; 
    } 

    public class Person { 

     [XmlAttribute("member")] 
     public MemberType Member { get; set; } 

     [XmlAttribute("id")] 
     public int Id { get; set; } 

     [XmlElement] 
     public string Surname { get; set; } 

     [XmlElement] 
     public string Forename { get; set; } 

     [XmlElement("Person")] 
     public List<Person> People; 
    } 

    public enum MemberType { 
     Father, 
     Mother, 
     Son, 
     Daughter 
    } 

तो Family एक विधि इस तरह के रूप में परिभाषित किया गया है:

public IEnumerable<Person> Find (Func<Person, bool> predicate) { 
    // how do I get SelectMany to flatten the list? 
    foreach (var p in family.Person.SelectMany(p => p)) { 
     if(predicate(p)) { 
      yield return p; 
     } 
    } 
} 

मैं Person का एक चपटा सूची पर विधेय निष्पादित करने में सक्षम होने की जरूरत है। ऊपर दिए गए उदाहरण में SelectMany सूची को फ़्लैटन नहीं कर रहा है जैसा कि मैंने आशा की थी। उपर्युक्त वास्तव में संकलित नहीं होगा क्योंकि अनुमानित प्रकार निर्धारित नहीं किया जा सकता है।

मैं परिवार कैसे प्राप्त कर सकता हूं। व्यक्ति संग्रह व्यक्ति की एक चतुर सूची बनने के लिए?

Answer 1

public IEnumerable<Person> Find(IEnumerable<Person> input, Func<Person, bool> predicate) { 
    return input.Select(p => 
     { 
      var thisLevel = new List<Person>(); 
      if(predicate(p)) 
       thisLevel.Add(p); 

      return thisLevel.Union(Find(p.People ?? new List<Person>(), predicate)); 
     } 
    ).SelectMany(p => p); 
} 

Answer 2

family.Personपहले से ही एक फ़्लैटेड सूची है; SelectMany पर कॉल करने की आवश्यकता नहीं है।

foreach (var p in family.Person) { 
    if(predicate(p)) { 
     yield return p; 
    } 
} 

इसके अलावा, आप और अधिक बस कर सकते हैं:

public IEnumerable<Person> Find (Func<Person, bool> predicate) { 
    return family.Person.Where(predicate); 
} 

Answer 3

आप दोनों SelectMany और yield return जरूरत नहीं है - आप एक या दूसरे की जरूरत है:

public IEnumerable<Person> Find (Func<Person, bool> predicate) { 
    foreach (var p in family.Person) { 
     if(predicate(p)) { 
      yield return p; 
     } 
    } 
} 

या

public IEnumerable<Person> Find (Func<Person, bool> predicate) { 
    return family.Person.Where(p => predicate(p)); // Can be written simply as Where(predicate) 
} 

Answer 4

मेरे ज्ञान के लिए, इसे पूरा करने का सबसे आसान तरीका एक सहायक का उपयोग कर रहा है।

private List<Person> FlattenTree(Person person) 
    { 
     var accumulator = new List<Person>(); 
     FlattenPersonHelper(person, accumulator); 

     return accumulator; 
    } 


    private void FlattenPersonHelper(Person person, List<Person> accumulator) 
    { 
     accumulator.Add(person); 

     foreach (var child in person.People) 
     { 
      FlattenPersonHelper(child, accumulator); 
     } 
     return; 
    } 

फिर आप इस सूची के खिलाफ अपने विधेय चला सकते हैं:

public IEnumerable<Person> FindLevel2 (Func<Person, bool> predicate) 
{ 
    return family.Person.SelectMany(p => p.People).Where(predicate); 
} 

---

आप एक मनमाना गहराई की पैदल दूरी पर वास्तव में चाहते हो सकता है:

public IEnumerable<Person> Find (Func<Person, bool> predicate) { 
    var familyRoot = new Person() { People = family.Person }; 
    return FlattenTree(familyRoot).Where(predicate); 
} 

Answer 5

SelectMany केवल पदानुक्रम में से एक स्तर सपाट पदानुक्रम का। यह सबसे अच्छा रिकर्सन (अनचाहे) द्वारा किया जाता है।

public IEnumerable<Person> Find(Func<Person, bool> predicate) 
{ 
    foreach(Person p in family.Person) 
    { 
    IEnumerable<Person> result = FindFromPerson(p); 
    foreach(Person x in result) 
    { 
     yield return x; 
    } 
    } 
} 

public IEnumerable<Person> FindFromPerson(Person p, Func<Person, bool> predicate) 
{ 
    if predicate(p) 
    { 
    yield return p; 
    } 
    foreach(Person child in p.People) 
    { 
    IEnumerable<Person> childResults = FindFromPerson(child); 
    foreach(Person x in childResults) 
    { 
     yield return x; 
    } 
    } 
}