LINQ: Counting Nombre total de Nested éléments

Question

J'ai une table de données qui contient un-à-plusieurs auto-référentiel:

Plant 
{ 
    ID, 
    Name, 
    ParentID 
} 

Je suis en train de créer une requête LINQ qui me dira le total nombre de descendants provenant d'une plante.

Exemple:

J'ai 5 plantes:

One {ID = 1, Name = Pine, Parent = null};// This is the root 
    Two {ID = 2, Name = Evergreen, Parent = 1} 
     Three {ID = 3, Name = Winter Evergreen, Parent = 2} 
    Four {ID = 4, Name = Christmas Tree, Parent = 1} 
Five {ID = 5, Name = Maple, Parent = null};// This is the root 

Quand j'appelle ma requête LINQ avec une entrée de ID = 1, je veux qu'il return 3, parce qu'il ya 3 descendants de One; Deux, Trois et Quatre. Five n'est pas un descendant de One. La seule façon de le faire implique des requêtes linq récursives imbriquées sur les résultats internes. Je n'ai aucune idée de comment faire cela et je me sens comme s'il y avait un moyen plus facile. J'utilise C# 4.0 et LINQ si cela est important.

Answer 1

Si vous utilisez SQL Server, la requête que vous voulez construire serait:

DECLARE @TargetElementId int 
SET @TargetElementId = 1; 

WITH Plants AS 
(
    SELECT ID, Name, ParentId 
    FROM PlantsTable 
    WHERE ParentId = @TargetElementId 

    UNION ALL 

    SELECT ID, Name, ParentId 
    FROM PlantsTable 
    INNER JOIN Plants ON PlantsTable.ParentId = Plants.ID 
) 
SELECT COUNT(ID) - 1 FROM Plants 

Je ne crois pas que cela puisse être fait avec LinqToSql, voir Common Table Expression (CTE) in linq-to-sql?, qui est une question de même nature .

Answer 2

EDIT Ajout d'un code prenant en charge LINQ to SQL grâce au commentaire @Kirk Woll.

class Program 
{ 
    private static Table<Plant> plants; 

    static void Main(string[] args) 
    { 
     using (var dataContext = new DataClasses1DataContext()) 
     { 
      plants = dataContext.Plants; 
      var treesNodes = GetTreesNodes(plants.Where(plant => plant.ID == 1)); 
      Console.WriteLine(string.Join(",", 
              treesNodes.Select(plant => plant.ID))); 
     } 
    } 

    public static IEnumerable<Plant> GetTreesNodes(IEnumerable<Plant> roots) 
    { 
     if(!roots.Any()) 
     { 
      return roots; 
     } 

     var children = roots.SelectMany(root => 
            plants.Where(plant => plant.Parent == root)); 
     return roots.Union(GetTreesNodes(children)); 
    } 

} 

version précédente qui correspondent à LINQ to Objects:

Cette méthode peut fournir tous les nœuds de l'arbre:

public IEnumerable<Plant> GetTreesNodes(IEnumerable<Plant> roots) 
{ 
    if(!roots.Any()) 
    { 
     return Enumerable.Empty<Plant>(); 
    } 

    var rootsIds = roots.Select(root => root.ID); 
    var children = plants.Where(plant => rootsIds.Contains(plant.Parent)); 
    return roots.Union(GetTreesNodes(children)); 
} 

Il peut être utilisé comme dans l'exemple suivant:

[Test] 
public void ExampleTest() 
{ 
    var One = new Plant() {ID = 1, Name = "Pine", Parent = 0}; 
    var Two = new Plant() {ID = 2, Name = "Evergreen", Parent = 1}; 
    var Three = new Plant() {ID = 3, Name = "Winter Evergreen", Parent = 2}; 
    var Four = new Plant() {ID = 4, Name = "Christmas Tree", Parent = 1}; 
    var Five = new Plant() {ID = 5, Name = "Maple", Parent = 0}; 

    plants = new []{One,Two,Three,Four,Five}; 

    var nestedElements = GetTreesNodes(new[]{One}); 
    var numOfNestedElementsWithoutRoot = nestedElements.Count()-1; 

    Assert.That(numOfNestedElementsWithoutRoot, Is.EqualTo(3)); 
} 

Le code suppose qu'il n'y a pas de re les ferences.