通过LINQ进行递归选择？

Question

可能重复：
linq to sql recursive query

我被困具有建立一个递归通过LINQ选择自我引用表。

我使用这个类：

public class DivisionHierarchy 
{ 
    public Division Division { get; set; } 
    public IEnumerable<DivisionHierarchy> Divisions { get; set; } 
} 

和我创造了这个功能，但不知何故，它是无限的。

public IEnumerable<DivisionHierarchy> GetDivisionHierarchy(IEnumerable<Division> allDivisions, Division parentDivision) 
{ 
    Guid? parentDivisionId = null; 

    if (parentDivision != null) 
     parentDivisionId = parentDivision.DivisionID; 

    var childDivisions = allDivisions.Where(e => e.DivisionID == parentDivisionId); 

    Collection<DivisionHierarchy> hierarchy = new Collection<DivisionHierarchy>(); 

    foreach (var div in childDivisions) 
     hierarchy.Add(new DivisionHierarchy() { Division = div, Divisions = GetDivisionHierarchy(allDivisions, div) }); 

    return hierarchy; 
} 

任何线索我可以从哪里开始？

谢谢！

P.S.有没有其他方法可以做到这一点？基于http://www.scip.be/index.php?Page=ArticlesNET18#AsHierarchy

，我发现我的错误

---

更新。

有两件事要实现： 1.应该在数据库下创建根节点。

码一点点

予改变。

Guid divisionID = Guid.Parse("5b487b3d-e9be-413f-b611-2fd7491e0d0d"); // Hardcoded somehow 
var rootDivision = db.Divisions.Where(i => i.ID == divisionID).FirstOrDefault(); 
var divisionHierarchy = GetDivisionHierarchy(db.Divisions.AsEnumerable(), rootDivision); 

...

public IEnumerable<DivisionHierarchy> GetDivisionHierarchy(IEnumerable<Division> allDivisions, Division parentDivision) 
     { 
      Guid? parentDivisionId = null; 

      if (parentDivision != null) 
       parentDivisionId = parentDivision.ID; 

      var childDivisions = allDivisions.Where(division => division.DivisionID == parentDivisionId); 

      Collection<DivisionHierarchy> hierarchy = new Collection<DivisionHierarchy>(); 

      foreach (var div in childDivisions) 
      { 
       DivisionHierarchy divisionHierarchy = new DivisionHierarchy(); 
       divisionHierarchy.Division = div; 
       divisionHierarchy.Divisions = GetDivisionHierarchy(allDivisions, div); 
       hierarchy.Add(divisionHierarchy); 
      } 

      return hierarchy; 
     } 

Answer 1

我会加载部门在非递归的方式，然后设置在代码中递归关系。这是一个例子，这是一个懒惰的方式

public class Division 
{ 
    public int ID { get; set; } 
    public int DivisionID { get; set; } 
    public string Name { get; set; } 
    public string Description { get; set; } 

    private static List<Division> _divisions; 
    public static List<Division> Divisions 
    { 
     get 
     { 
      if (_divisions == null) { 
       LoadAndSetUpDivisionsHierarchy(); 
      } 
      return _divisions; 
     } 
    } 

    private static Dictionary<int, Division> _divisionsByID; 
    public static Dictionary<int, Division> DivisionsByID 
    { 
     get 
     { 
      if (_divisionsByID == null) { 
       LoadAndSetUpDivisionsHierarchy(); 
      } 
      return _divisionsByID; 
     } 
    } 

    private static Division _root; 
    public static Division Root 
    { 
     get 
     { 
      if (_root == null) { 
       LoadAndSetUpDivisionsHierarchy(); 
      } 
      return _root; 
     } 
    } 

    private Division _parentDivision; 
    public Division ParentDivision 
    { 
     get 
     { 
      if (_parentDivision == null && DivisionID != 0) { 
       _parentDivision = DivisionsByID[DivisionID]; 

      } 
      return _parentDivision; 
     } 
    } 

    private List<Division> _subDivisions = new List<Division>(); 
    public List<Division> SubDivisions 
    { 
     get { return _subDivisions; } 
    } 

    private static void LoadAndSetUpDivisionsHierarchyHierarchy() 
    { 
     // Load the divisions in a non-recursive way using LINQ 
     // (details not shown here). 
     _divisions = LoadDivisions(); 

     // Add the divisions in a dictionary by id 
     _divisionsByID = new Dictionary<int, Division>(_divisions.Count); 
     foreach (Division division in _divisions) { 
      _divisionsByID.Add(division.ID, division); 
     } 

     // Define sub-divisions and root division 
     foreach (Division division in _divisions) { 
      if (division.DivisionID == 0) { 
       _root = division; 
      } else if (division.ParentDivision != null) { 
       division.ParentDivision.SubDivisions.Add(division); 
      } 
     } 
    } 

    private static List<Division> LoadDivisions() 
    { 
     throw new NotImplementedException(); 
    } 
}