如何在集合中找到一个对象，其中集合具有相同类型的子集合？

Question

如果我有一个Collection<T>，每个T对象可以有一个孩子Collection<T>以及一个Collection<T2>，是如何找到的T2目标的最佳途径，在那里我知道T2对象的string name，我有一个Collection<T>？

Answer 1

递归搜索实例级别T2集合和子T集合，直到找到匹配项。

public T2 Find(T primaryObject, string searchValue) 
{ 
    var secondaryObject = primaryObject.T2Collection.SingleOrDefault(x => x.Name == searchValue) 
    if (secondaryObject != null) 
     return secondaryObject; 

    foreach (var childObject in primaryObject.T1Collection) 
    { 
     secondaryObject = Find(childObject, searchValue); 
     if (secondaryObject != null) 
      return secondaryObject; 
    } 

    return null; 
} 

Answer 2

你需要一个递归的方法来搜索所有T2匹配搜索值：

public class Program 
{ 
    private static IEnumerable<Bar> Find(Foo foo, String name) 
    { 
     foreach (var x in foo.Bars.Where(x => x.Name == name)) 
      yield return x; 

     var bars = foo.Foos?.SelectMany(x => Find(x, name)) ?? new Bar[0]; 
     foreach (var y in bars) 
      yield return y; 
    } 

    public static void Main(String[] args) 
    { 
     var foo = new Foo 
     { 
      Bars = new List<Bar> 
      { 
       new Bar { Name = "n1" }, 
       new Bar { Name = "n2" }, 
       new Bar { Name = "n3" }, 
       new Bar { Name = "n4" } 
      }, 
      Foos = new List<Foo> 
      { 
       new Foo 
       { 
        Bars = new List<Bar> 
        { 
         new Bar { Name = "n1" }, 
         new Bar { Name = "n2" }, 
         new Bar { Name = "n3" }, 
         new Bar { Name = "n4" } 
        }, 
        Foos = new List<Foo> 
        { 
         new Foo 
         { 
          Bars = new List<Bar> 
          { 
           new Bar { Name = "n1" }, 
           new Bar { Name = "n2" }, 
           new Bar { Name = "n3" }, 
           new Bar { Name = "n4" } 
          } 
         } 
        } 
       }, 
       new Foo 
       { 
        Bars = new List<Bar> 
        { 
         new Bar { Name = "n1" }, 
         new Bar { Name = "n2" }, 
         new Bar { Name = "n3" }, 
         new Bar { Name = "n4" } 
        } 
       } 
      } 
     }; 

     foreach (var x in Find(foo, "n1")) 
      Console.WriteLine(x.Name); 

     Console.ReadLine(); 
    } 
} 

public class Foo 
{ 
    #region Properties 

    public IEnumerable<Foo> Foos { get; set; } 
    public IEnumerable<Bar> Bars { get; set; } 

    #endregion 
} 

public class Bar 
{ 
    #region Properties 

    public String Name { get; set; } 

    #endregion 
} 

Answer 3

无扩展名通常可以用来代替递归函数：

using System.Reactive.Linq; 
public class T2 
{ 
    public string Name; 
} 

public class T 
{ 
    public IEnumerable<T2> t2Collection; 
    public IEnumerable<T> tCollection; 
} 

public T2 Find(IEnumerable<T> primaryCollection, string searchValue) 
{ 
    T2 result = null; 
    Observable.Generate(
      new 
      { 
       currentCollection = primaryCollection, 
       searchedT2 = default(T2) 
      }, 
      state => state.searchedT2 == default(T2), 
      state => new 
      { 
      currentCollection = state.currentCollection.SelectMany(t => t.tCollection), 
      searchedT2 = state.currentCollection.SelectMany(t => t.t2Collection).FirstOrDefault(t2 => t2.Name == searchValue) 
      }, 
      state => state.searchedT2 
      ).Subscribe(t2=>result=t2); 

    return result; 
    }