所以我有一个基本上是
ID, ParentID, MenuName, [Lineage, Depth]
最后两列是自动计算的以帮助搜索，所以我们现在可以忽略它们。
我正在创建一个包含多个类别的下拉菜单系统。
不幸的是，我不认为 EF 与超过 1 级深度的自引用表配合得很好。所以我有几个选择
1) 创建查询，按深度排序，然后在 C# 中创建一个自定义类，一次填充一个深度。
2) 想办法在 EF 中急切加载数据，我认为不可能有无限数量的关卡，只有固定数量。
3）其他一些我什至不确定的方式。
欢迎任何意见！
我已经使用 EF 成功映射了分层数据。
Establishment以实体为例。这可以代表更大的组织结构中的公司、大学或其他一些单位：
public class Establishment : Entity
{
public string Name { get; set; }
public virtual Establishment Parent { get; set; }
public virtual ICollection<Establishment> Children { get; set; }
...
}
这是父/子属性的映射方式。这样，当您设置 1 个实体的 Parent 时，Parent 实体的 Children 集合会自动更新：
// ParentEstablishment 0..1 <---> * ChildEstablishment
HasOptional(d => d.Parent)
.WithMany(p => p.Children)
.Map(d => d.MapKey("ParentId"))
.WillCascadeOnDelete(false); // do not delete children when parent is deleted
请注意，到目前为止，我还没有包含您的 Lineage 或 Depth 属性。您是对的，EF 不适用于生成具有上述关系的嵌套分层查询。我最终决定的是添加一个新的动名词实体，以及 2 个新的实体属性：
public class EstablishmentNode : Entity
{
public int AncestorId { get; set; }
public virtual Establishment Ancestor { get; set; }
public int OffspringId { get; set; }
public virtual Establishment Offspring { get; set; }
public int Separation { get; set; }
}
public class Establishment : Entity
{
...
public virtual ICollection<EstablishmentNode> Ancestors { get; set; }
public virtual ICollection<EstablishmentNode> Offspring { get; set; }
}
在写这篇文章时，hazzik 发布了一个与这种方法非常相似的答案。不过，我会继续写下去，以提供一个稍微不同的选择。我喜欢让我的祖先和后代动名词类型成为实际的实体类型，因为它可以帮助我获得祖先和后代之间的分离（你所说的深度）。这是我如何映射这些：
private class EstablishmentNodeOrm : EntityTypeConfiguration<EstablishmentNode>
{
internal EstablishmentNodeOrm()
{
ToTable(typeof(EstablishmentNode).Name);
HasKey(p => new { p.AncestorId, p.OffspringId });
}
}
...最后，企业实体中的识别关系：
// has many ancestors
HasMany(p => p.Ancestors)
.WithRequired(d => d.Offspring)
.HasForeignKey(d => d.OffspringId)
.WillCascadeOnDelete(false);
// has many offspring
HasMany(p => p.Offspring)
.WithRequired(d => d.Ancestor)
.HasForeignKey(d => d.AncestorId)
.WillCascadeOnDelete(false);
另外，我没有使用 sproc 来更新节点映射。相反，我们有一组内部命令，它们将根据 Parent & Children 属性派生/计算 Ancestors 和 Offspring 属性。但是最终，您最终能够像在 hazzik 的回答中那样进行一些非常相似的查询：
// load the entity along with all of its offspring
var establishment = dbContext.Establishments
.Include(x => x.Offspring.Select(y => e.Offspring))
.SingleOrDefault(x => x.Id == id);
主要实体与其祖先/后代之间的桥梁实体的原因再次是因为该实体让您获得分离。此外，通过将其声明为标识关系，您可以从集合中删除节点，而无需显式调用 DbContext.Delete()。
// load all entities that are more than 3 levels deep
var establishments = dbContext.Establishments
.Where(x => x.Ancestors.Any(y => y.Separation > 3));
您可以使用支持层次结构表来预先加载无限级别的树。
因此，您需要添加两个集合Ancestors，并且Descendants两个集合都应该以多对多的方式映射到支持表。
public class Tree
{
public virtual Tree Parent { get; set; }
public virtual ICollection<Tree> Children { get; set; }
public virtual ICollection<Tree> Ancestors { get; set; }
public virtual ICollection<Tree> Descendants { get; set; }
}
Ancestors 将包含实体的所有祖先（父母、祖父母、祖父母等），Descendants并将包含实体的所有后代（孩子、孙子女、孙孙子女等）。
现在你必须先用 EF Code First 映射它：
public class TreeConfiguration : EntityTypeConfiguration<Tree>
{
public TreeConfiguration()
{
HasOptional(x => x.Parent)
.WithMany(x => x.Children)
.Map(m => m.MapKey("PARENT_ID"));
HasMany(x => x.Children)
.WithOptional(x => x.Parent);
HasMany(x => x.Ancestors)
.WithMany(x => x.Descendants)
.Map(m => m.ToTable("Tree_Hierarchy").MapLeftKey("PARENT_ID").MapRightKey("CHILD_ID"));
HasMany(x => x.Descendants)
.WithMany(x => x.Ancestors)
.Map(m => m.ToTable("Tree_Hierarchy").MapLeftKey("CHILD_ID").MapRightKey("PARENT_ID"));
}
}
现在有了这个结构，你可以像下面这样急切地获取
context.Trees.Include(x => x.Descendants).Where(x => x.Id == id).SingleOrDefault()
此查询将加载实体id及其所有后代。
您可以使用以下存储过程填充支持表：
CREATE PROCEDURE [dbo].[FillHierarchy] (@table_name nvarchar(MAX), @hierarchy_name nvarchar(MAX))
AS
BEGIN
DECLARE @sql nvarchar(MAX), @id_column_name nvarchar(MAX)
SET @id_column_name = '[' + @table_name + '_ID]'
SET @table_name = '[' + @table_name + ']'
SET @hierarchy_name = '[' + @hierarchy_name + ']'
SET @sql = ''
SET @sql = @sql + 'WITH Hierachy(CHILD_ID, PARENT_ID) AS ( '
SET @sql = @sql + 'SELECT ' + @id_column_name + ', [PARENT_ID] FROM ' + @table_name + ' e '
SET @sql = @sql + 'UNION ALL '
SET @sql = @sql + 'SELECT e.' + @id_column_name + ', e.[PARENT_ID] FROM ' + @table_name + ' e '
SET @sql = @sql + 'INNER JOIN Hierachy eh ON e.' + @id_column_name + ' = eh.[PARENT_ID]) '
SET @sql = @sql + 'INSERT INTO ' + @hierarchy_name + ' ([CHILD_ID], [PARENT_ID]) ( '
SET @sql = @sql + 'SELECT [CHILD_ID], [PARENT_ID] FROM Hierachy WHERE [PARENT_ID] IS NOT NULL '
SET @sql = @sql + ') '
EXECUTE (@sql)
END
GO
甚至您可以将支持表映射到视图：
CREATE VIEW [Tree_Hierarchy]
AS
WITH Hierachy (CHILD_ID, PARENT_ID)
AS
(
SELECT [MySuperTree_ID], [PARENT_ID] FROM [MySuperTree] AS e
UNION ALL
SELECT e.[MySuperTree_ID], e.[PARENT_ID] FROM [MySuperTree] AS e
INNER JOIN Hierachy AS eh ON e.[MySuperTree_ID] = eh.[PARENT_ID]
)
SELECT [CHILD_ID], [PARENT_ID] FROM Hierachy WHERE [PARENT_ID] IS NOT NULL
GO
我已经花了一段时间试图修复您解决方案中的错误。存储过程真的不会产生子、孙等。下面你会发现固定的存储过程：
CREATE PROCEDURE dbo.UpdateHierarchy AS
BEGIN
DECLARE @sql nvarchar(MAX)
SET @sql = ''
SET @sql = @sql + 'WITH Hierachy(ChildId, ParentId) AS ( '
SET @sql = @sql + 'SELECT t.Id, t.ParentId FROM dbo.Tree t '
SET @sql = @sql + 'UNION ALL '
SET @sql = @sql + 'SELECT h.ChildId, t.ParentId FROM dbo.Tree t '
SET @sql = @sql + 'INNER JOIN Hierachy h ON t.Id = h.ParentId) '
SET @sql = @sql + 'INSERT INTO dbo.TreeHierarchy (ChildId, ParentId) ( '
SET @sql = @sql + 'SELECT DISTINCT ChildId, ParentId FROM Hierachy WHERE ParentId IS NOT NULL '
SET @sql = @sql + 'EXCEPT SELECT t.ChildId, t.ParentId FROM dbo.TreeHierarchy t '
SET @sql = @sql + ') '
EXECUTE (@sql)
END
错误：错误的参考。翻译@hazzik 代码是：
SET @sql = @sql + 'SELECT t.ChildId, t.ParentId FROM dbo.Tree t '
但应该是
SET @sql = @sql + 'SELECT h.ChildId, t.ParentId FROM dbo.Tree t '
我还添加了允许您更新 TreeHierarchy 表的代码，而不仅仅是在您填充它时。
SET @sql = @sql + 'EXCEPT SELECT t.ChildId, t.ParentId FROM dbo.TreeHierarchy t '
还有魔法。此过程或更确切地说是 TreeHierarchy 允许您仅通过包含祖先（不是子代而不是后代）来加载子代。
using (var context = new YourDbContext())
{
rootNode = context.Tree
.Include(x => x.Ancestors)
.SingleOrDefault(x => x.Id == id);
}
现在 YourDbContext 将返回一个 rootNode，其中包含已加载的子节点、rootName 的子节点（孙子节点）的子节点，等等。
我知道这个解决方案一定有问题。这并不简单。使用此解决方案，EF6 需要另一个 hack 包来管理一个简单的树（fe.删除）。所以最后我找到了一个简单的解决方案，但结合了这种方法。
首先让实体保持简单：只需父级和子级列表就足够了。映射也应该很简单：
HasOptional(x => x.Parent)
.WithMany(x => x.Children)
.Map(m => m.MapKey("ParentId"));
HasMany(x => x.Children)
.WithOptional(x => x.Parent);
然后添加迁移（代码优先：迁移：包控制台：Add-Migration Hierarchy）或以其他方式添加存储过程：
CREATE PROCEDURE [dbo].[Tree_GetChildren] (@Id int) AS
BEGIN
WITH Hierachy(ChildId, ParentId) AS (
SELECT ts.Id, ts.ParentId
FROM med.MedicalTestSteps ts
UNION ALL
SELECT h.ChildId, ts.ParentId
FROM med.MedicalTestSteps ts
INNER JOIN Hierachy h ON ts.Id = h.ParentId
)
SELECT h.ChildId
FROM Hierachy h
WHERE h.ParentId = @Id
END
然后，当您尝试从数据库接收树节点时，只需分两步进行：
//Get children IDs
var sql = $"EXEC Tree_GetChildren {rootNodeId}";
var children = context.Database.SqlQuery<int>(sql).ToList<int>();
//Get root node and all it's children
var rootNode = _context.TreeNodes
.Include(s => s.Children)
.Where(s => s.Id == id || children.Any(c => s.Id == c))
.ToList() //MUST - get all children from database then get root
.FirstOrDefault(s => s.Id == id);
这一切。此查询可帮助您获取根节点并加载所有子节点。不玩介绍祖先和后代。
还请记住，当您尝试保存子节点时，请这样做：
var node = new Node { ParentId = rootNode }; //Or null, if you want node become a root
context.TreeNodess.Add(node);
context.SaveChanges();
这样做，而不是通过将子节点添加到根节点。
我最近研究的另一个实现选项......
我的树很简单。
public class Node
{
public int NodeID { get; set; }
public string Name { get; set; }
public virtual Node ParentNode { get; set; }
public int? ParentNodeID { get; set; }
public virtual ICollection<Node> ChildNodes { get; set; }
public int? LeafID { get; set; }
public virtual Leaf Leaf { get; set; }
}
public class Leaf
{
public int LeafID { get; set; }
public string Name { get; set; }
public virtual ICollection<Node> Nodes { get; set; }
}
我的要求，没有那么多。
给定一组叶子和一个祖先，显示该祖先的子孙，其后代在该集合内具有叶子
一个类比是磁盘上的文件结构。当前用户有权访问系统上的文件子集。当用户打开文件系统树中的节点时，我们只想显示最终将引导他们到他们可以看到的文件的用户节点。我们不想向他们显示他们无权访问的文件的文件路径（出于安全原因，例如，泄露某种类型的文档的存在）。
我们希望能够将此过滤器表示为IQueryable<T>，因此我们可以将其应用于任何节点查询，过滤掉不需要的结果。
为此，我创建了一个表值函数，它返回树中节点的后代。它通过 CTE 完成此操作。
CREATE FUNCTION [dbo].[DescendantsOf]
(
@parentId int
)
RETURNS TABLE
AS
RETURN
(
WITH descendants (NodeID, ParentNodeID, LeafID) AS(
SELECT NodeID, ParentNodeID, LeafID from Nodes where ParentNodeID = @parentId
UNION ALL
SELECT n.NodeID, n.ParentNodeID, n.LeafID from Nodes n inner join descendants d on n.ParentNodeID = d.NodeID
) SELECT * from descendants
)
现在，我使用的是 Code First，所以我不得不使用
https://www.nuget.org/packages/EntityFramework.Functions
为了将函数添加到我的 DbContext
[TableValuedFunction("DescendantsOf", "Database", Schema = "dbo")]
public IQueryable<NodeDescendant> DescendantsOf(int parentID)
{
var param = new ObjectParameter("parentId", parentID);
return this.ObjectContext().CreateQuery<NodeDescendant>("[DescendantsOf](@parentId)", param);
}
具有复杂的返回类型（无法重用 Node，正在调查）
[ComplexType]
public class NodeDescendant
{
public int NodeID { get; set; }
public int LeafID { get; set; }
}
当用户在树中展开一个节点时，将它们放在一起允许我获得过滤后的子节点列表。
public static Node[] GetVisibleDescendants(int parentId)
{
using (var db = new Models.Database())
{
int[] visibleLeaves = SuperSecretResourceManager.GetLeavesForCurrentUserLol();
var targetQuery = db.Nodes as IQueryable<Node>;
targetQuery = targetQuery.Where(node =>
node.ParentNodeID == parentId &&
db.DescendantsOf(node.NodeID).Any(x =>
visibleLeaves.Any(y => x.LeafID == y)));
// Notice, still an IQueryable. Perform whatever processing is required.
SortByCurrentUsersSavedSettings(targetQuery);
return targetQuery.ToArray();
}
}
重要的是要注意该函数是在服务器上执行的，而不是在应用程序中执行的。这是执行的查询
SELECT
[Extent1].[NodeID] AS [NodeID],
[Extent1].[Name] AS [Name],
[Extent1].[ParentNodeID] AS [ParentNodeID],
[Extent1].[LeafID] AS [LeafID]
FROM [dbo].[Nodes] AS [Extent1]
WHERE ([Extent1].[ParentNodeID] = @p__linq__0) AND ( EXISTS (SELECT
1 AS [C1]
FROM ( SELECT
[Extent2].[LeafID] AS [LeafID]
FROM [dbo].[DescendantsOf]([Extent1].[NodeID]) AS [Extent2]
) AS [Project1]
WHERE EXISTS (SELECT
1 AS [C1]
FROM ( SELECT 1 AS X ) AS [SingleRowTable1]
WHERE [Project1].[LeafID] = 17
)
))
注意上面查询中的函数调用。
@danludwig 感谢您的回答
我为更新节点编写了一些函数，它工作得非常完美。我的代码很好还是应该以其他方式编写？
public void Handle(ParentChanged e)
{
var categoryGuid = e.CategoryId.Id;
var category = _context.Categories
.Include(cat => cat.ParentCategory)
.First(cat => cat.Id == categoryGuid);
if (null != e.OldParentCategoryId)
{
var oldParentCategoryGuid = e.OldParentCategoryId.Id;
if (category.ParentCategory.Id == oldParentCategoryGuid)
{
throw new Exception("Old Parent Category mismatch.");
}
}
(_context as DbContext).Configuration.LazyLoadingEnabled = true;
RemoveFromAncestors(category, category.ParentCategory);
var newParentCategoryGuid = e.NewParentCategoryId.Id;
var parentCategory = _context.Categories
.First(cat => cat.Id == newParentCategoryGuid);
category.ParentCategory = parentCategory;
AddToAncestors(category, category.ParentCategory, 1);
_context.Commit();
}
private static void RemoveFromAncestors(Model.Category.Category mainCategory, Model.Category.Category ancestorCategory)
{
if (null == ancestorCategory)
{
return;
}
while (true)
{
var offspring = ancestorCategory.Offspring;
offspring?.RemoveAll(node => node.OffspringId == mainCategory.Id);
if (null != ancestorCategory.ParentCategory)
{
ancestorCategory = ancestorCategory.ParentCategory;
continue;
}
break;
}
}
private static int AddToAncestors(Model.Category.Category mainCategory,
Model.Category.Category ancestorCategory, int deep)
{
var offspring = ancestorCategory.Offspring ?? new List<CategoryNode>();
if (null == ancestorCategory.Ancestors)
{
ancestorCategory.Ancestors = new List<CategoryNode>();
}
var node = new CategoryNode()
{
Ancestor = ancestorCategory,
Offspring = mainCategory
};
offspring.Add(node);
if (null != ancestorCategory.ParentCategory)
{
deep = AddToAncestors(mainCategory, ancestorCategory.ParentCategory, deep + 1);
}
node.Separation = deep;
return deep;
}