递归列表中包含财产

Question

我有一个类如下：

public class Feature 
{ 
    public string Name { get; set; } 

    public string DisplayName { get; set; } 

    public List<Feature> SubFeatures { get; set; } = new List<Feature>(); 
} 

然后我有一个List<Feature> features = new List<Feature>;在那里我存储我的所有功能。

现在，我想知道在我的features变量中是否存在特定Feature（按名称）。

然而，它可以存在于例如SubFeature的SubFeature的任何级别（SubFeature）。

我已经得到的最接近的是这样的：

public bool FeatureExists(Feature feature, string name) 
{ 
    return feature.Name == name || feature.SubFeatures.Select(subFeature => FeatureExists(subFeature, name)).Any(result => result); 
} 

但它涉及到有使用上的FeatureExists()呼叫者在同一时间给它传递一个顶级功能。

我确定有一个更简单的方法来做到这一点，我该如何正确地做到这一点？

Answer 1

定义一个递归方法是这样的：

public IEnumerable<Feature> FeatureAndSubFeatures(Feature feature) 
{ 
    yield return feature; 

    foreach (var subFeature in feature.SubFeatures) 
    { 
     foreach (var child in FeatureAndSubFeatures(subFeature)) 
     { 
      yield return child; 
     } 
    } 
} 

然后使用它：

FeatureAndSubFeatures(feature).Any(x => x.Name == name); 

另一种选择是把这个方法在功能本身，所谓的像SelfAndSubFeaturesRecursive（）。

这种方法 - 编写一个递归地扁平化树的方法，而不是编写一个特定方法来搜索具有给定名称的特征 - 是非常灵活的，因为您可以使用它来搜索任何基于树的节点标准或节点的任何子集，而不是专门用于查找具有特定名称的节点。

您也可以编写它以开始使用一组功能。喜欢的东西：

public IEnumerable<Feature> FeaturesAndSubFeatures(IEnumerable<Feature> features) 
{ 
    foreach (var feature in features) 
    { 
     yield return feature; 

     foreach (var child in FeaturesAndSubFeatures(feature.SubFeatures)) 
     { 
      yield return child; 
     } 
    } 
} 

这仅仅是有用的，如果你总是有特征集合出发，但你做的情况下节省了SelectMany。

Answer 2

你想为你做一个单独的递归方法。 试试这个：

public bool FeatureExists(Feature feature, string name) { 
    if(feature.Name == name) { 
     return true; 
    } 
    if(!feature.SubFeatures.isEmpty) { 
     foreach(Feature subFeature in feature.SubFeatures){ 
      FeatureExists(subFeature, name) 
     } 
    } 
     return false; 
    } 

Answer 3

我尽量避免递归。这是一个版本，而不：

public bool FeatureExists(Feature feature, string name) 
{ 
    var featureQueue = new Queue<Feature>(); 
    featureQueue.Enqueue(feature); 
    while (featureQueue.Count > 0) 
    { 
     Feature current = featureQueue.Dequeue(); 
     if (feature.Name == name) 
      return true; 
     foreach (Feature f in current.SubFeatures) 
      featureQueue.Enqueue(f); 
    } 
    return false; 
} 

---

如果您发现本作评论，你可以使用一个通用的扩展方法，只要你需要递归检查，例如使用它的可读性：

public static class Extensions 
{ 
    public static bool RecursiveCheck<T>(this T rootItem, Func<T, IEnumerable<T>> getChildrenFunc, Func<T, bool> predicate) 
    { 
     var queue = new Queue<T>(); 
     queue.Enqueue(rootItem); 
     while (queue.Count > 0) 
     { 
      T current = queue.Dequeue(); 
      if (predicate(current)) 
       return true; 
      foreach (T child in getChildrenFunc(current)) 
       queue.Enqueue(child); 
     } 
     return false; 
    } 
} 

测试功能：

Feature f1 = new Feature 
{ 
    Name = "1", SubFeatures = new List<Feature> { new Feature {Name="1.1", SubFeatures = new List<Feature> {new Feature {Name= "thename" } } }} 
}; 

这简单的一行仍然是：

bool containsName = f1.RecursiveCheck<Feature>(f => f.SubFeatures, f => f.Name == "thename"); 

Answer 4

嗯，我不确定这是你问什么，但如果你想要更干净的代码，你可以写你的函数作为扩展方法，并使用LINQ而不是循环来获得更干净的代码。

public static bool FeatureExists(this Feature feature, string name) 
{ 
    return feature.Name == name || feature.SubFeatures.Select(subFeature => FeatureExists(subFeature, name)).Any(result => result); 
} 

然后

List<Feature> mainFeatures = new List<Feature>(); 
mainFeatures.Any(obj => obj.FeatureExists("abc")); 

如果你想事件更短，更干净的代码，你可以考虑有一个特征作为像母亲一样功能的所有功能，父母，然后打电话给你的递归方法在这一点。

但无论如何，考虑让你的方法扩展方法。

Answer 5

以下应该通过所有列表重复并填写“结果”与包含在整个层级中的所有可能的特征

public class Feature 
    { 
     public string Name { get; set; } 

     public string DisplayName { get; set; } 

     public List<Feature> SubFeatures { get; set; } = new List<Feature>(); 
    } 

其他类

List<feature> result = new List<feature>(); 

public void FindItems(Feature yourFeature) 
{ 
    result.add(yourFeature); 
    foreach(Feature feature in yourFeature) 
    { 
     if(feature.SubFeatures.count != 0) 
     { 
     foreach(Feature subfeature in feature) 
     { 
      FindItems(subfeature); 
     } 
     } 
     else 
     { 
     result.add(feature); 
     } 
    } 
}