我在数据库中有一棵树形结构，其中包含TreeNodes表。该表具有nodeId、parentId和parameterId。在EF中，结构类似于TreeNode.Children，其中每个子节点都是一个TreeNode...
我还有一个包含id、name和rootNodeId的Tree表。
最终，我想将树加载到TreeView中，但我无法想出如何一次性加载整个树。我尝试过：
var trees = from t in context.TreeSet.Include("Root").Include("Root.Children").Include("Root.Children.Parameter")
.Include("Root.Children.Children")
where t.ID == id
select t;
这将获取前两代，但不包括更多的后代。 如何加载完整的家谱树，包括所有世代和其他数据？
最近我遇到了这个问题，后来在想出一个简单的方法后，我偶然发现了这个问题。我提供了对Craig答案的编辑，提供了第四种方法，但是决策者认为它应该是另一个答案。对我来说没关系 :)
只要您的表格中的项目都知道它们属于哪棵树（在您的情况下似乎是这样：t.ID），这个方法就有效。话虽如此，不清楚您真正使用的实体是什么，但即使您有多个实体，如果Children不是TreeSet，那么您必须在实体中有一个FK
基本上，只需不使用Include():
var query = from t in context.TreeSet
where t.ID == id
select t;
// if TreeSet.Children is a different entity:
var query = from c in context.TreeSetChildren
// guessing the FK property TreeSetID
where c.TreeSetID == id
select c;
-- Item1
-- Item2
-- Item3
-- Item4
-- Item5
-- Item2
-- Item3
-- Item5
由于您可能希望从EF中只获取层次结构的实体，这不是您想要的，对吗？
..然后，排除在根级别存在的后代：
幸运的是，因为您的模型中有导航属性，子实体集合仍将被填充，正如您可以通过上面结果集的图示看到的那样。通过使用foreach()循环手动迭代结果集，并将这些根项目添加到一个new List<TreeSet>()中，现在您将拥有一个包含根元素和所有后代正确嵌套的列表。
如果您的树变得很大且性能是一个问题，您可以按升序排序返回集合，按ParentID（它是Nullable，对吧？）排序，以便所有根项都排在前面。像以前一样迭代并添加，但在遇到非空时中断循环。
var subset = query
// execute the query against the DB
.ToList()
// filter out non-root-items
.Where(x => !x.ParentId.HasValue);
现在subset看起来是这样的:
-- Item1
-- Item2
-- Item3
-- Item4
-- Item5
关于Craig的解决方案：
- 你真的不想使用懒加载来处理这个问题！一个基于n+1查询的设计将会对性能产生严重影响。
(嗯，公平地说，如果你要允许用户选择性地深入树形结构，那么它可能是合适的。只是不要使用懒加载获取所有内容！)- 我从未尝试过嵌套集，也不建议通过修改EF配置来实现这一点，因为有一个更简单的解决方案。
- 另一个合理的建议是创建一个提供自链接的数据库视图，然后将该视图映射到一个中间连接/链接/m2m表。个人认为，这种解决方案比必要的还要复杂，但它可能有其用处。
Entity Framework Core 3.1。 因此，即使树正在被填充，当访问“Children”时，代理也会触发额外的加载。 所以，解决方案是为每个返回的节点添加 dbContext.Entry(treeNode).Collection(n => n.Children).IsLoaded = true;。 - pmoleriInclude()时，你正在请求Entity Framework将你的查询翻译成SQL。因此请思考：如何编写一个返回任意深度树的SQL语句？其他人的回答没有帮到我，所以我想发表我的回答。
我的数据库有些不同，基本上我的表格包含一个ID和一个ParentID。这个表是递归的。以下代码可以获取所有的子元素，并将它们嵌套到最终列表中。
public IEnumerable<Models.MCMessageCenterThread> GetAllMessageCenterThreads(int msgCtrId)
{
var z = Db.MCMessageThreads.Where(t => t.ID == msgCtrId)
.Select(t => new MCMessageCenterThread
{
Id = t.ID,
ParentId = t.ParentID ?? 0,
Title = t.Title,
Body = t.Body
}).ToList();
foreach (var t in z)
{
t.Children = GetChildrenByParentId(t.Id);
}
return z;
}
private IEnumerable<MCMessageCenterThread> GetChildrenByParentId(int parentId)
{
var children = new List<MCMessageCenterThread>();
var threads = Db.MCMessageThreads.Where(x => x.ParentID == parentId);
foreach (var t in threads)
{
var thread = new MCMessageCenterThread
{
Id = t.ID,
ParentId = t.ParentID ?? 0,
Title = t.Title,
Body = t.Body,
Children = GetChildrenByParentId(t.ID)
};
children.Add(thread);
}
return children;
}
为了完整起见，这是我的模型：
public class MCMessageCenterThread
{
public int Id { get; set; }
public int ParentId { get; set; }
public string Title { get; set; }
public string Body { get; set; }
public IEnumerable<MCMessageCenterThread> Children { get; set; }
}
1. GetAllMessageCenterThreads返回一个列表，但只有一个项目（.Where(t=>t.ID == msgCtrId)）。2. 您的ParentID属性应该是可空的（int? vs int），而且ParentId = t.ParentID ?? 0,总是会返回'0'，因为ParentID不能为null（这不是Code-First吗？）。3. 看起来您的模型缺少一个属性：MessageCenterId。所有项目都应该有这个字段，这样您就可以通过该id获取所有项目。 - JoeBrockhauspublic class SomeEntity
{
public int Id { get; set; }
public int? ParentId { get; set; }
public string Name { get; set;
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace Microsoft.EntityFrameworkCore
{
public static class DbSetExtensions
{
public static async Task<TEntity[]> FindRecursiveAsync<TEntity, TKey>(
this DbSet<TEntity> source,
Expression<Func<TEntity, bool>> rootSelector,
Func<TEntity, TKey> getEntityKey,
Func<TEntity, TKey> getChildKeyToParent)
where TEntity: class
{
// Keeps a track of already processed, so as not to invoke
// an infinte recursion
var alreadyProcessed = new HashSet<TKey>();
TEntity[] result = await source.Where(rootSelector).ToArrayAsync();
TEntity[] currentRoots = result;
while (currentRoots.Length > 0)
{
TKey[] currentParentKeys = currentRoots.Select(getEntityKey).Except(alreadyProcessed).ToArray();
alreadyProcessed.AddRange(currentParentKeys);
Expression<Func<TEntity, bool>> childPredicate = x => currentParentKeys.Contains(getChildKeyToParent(x));
currentRoots = await source.Where(childPredicate).ToArrayAsync();
}
return result;
}
}
}
SomeEntity[] myEntities = await DataContext.SomeEntity.FindRecursiveAsync(
rootSelector: x => x.Id = 42,
getEntityKey: x => x.Id,
getChildKeyToParent: x => x.ParentId).ToArrayAsync();
);
或者，如果您可以在表中添加RootId列，则对于每个非根条目，您可以将此列设置为树的根的ID。 然后，您可以使用单个选择获取所有内容。
DataContext.SomeEntity.Where(x => x.Id == rootId || x.RootId == rootId)
DataContext.SomeEntity.Where(x => x.Id == rootId || x.RootId == rootId) 更好吗？ - Peter MorrisrootId，那么您就不需要在数据库中使用CTE。 CTE的价值在于执行所有递归迭代_在数据库中_，以便您不会产生连接和往返开销。 - JoeBrockhausvar roots = new HashSet<AncestralTagDto>(); //no parents
var allTags = new HashSet<AncestralTagDto>();
var startingTags = await _dataContext.ArticlesTags
.Include(p => p.Tag.Parents)
.Where(t => t.Article.CategoryId == categoryId)
.GroupBy(t => t.Tag)
.ToListAsync()
.ContinueWith(resultTask =>
resultTask.Result.Select(
grouping => new AncestralTagDto(
grouping.Key.Id,
grouping.Key.Name)));
var tagRelations = await _dataContext.TagsTags.Include(p => p.ParentTag).ToListAsync();
foreach (var tag in startingTags)
{
allTags.Add(tag);
GetParents(tag);
}
return roots;
void GetParents(AncestralTagDto tag)
{
var parents = tagRelations.Where(c => c.ChildTagId == tag.Id).Select(p => p.ParentTag);
if (parents.Any()) //then it's not a root tag; keep climbing down
{
foreach (var parent in parents)
{
//have we already seen this parent tag before? If not, instantiate the dto.
var parentDto = allTags.SingleOrDefault(i => i.Id == parent.Id);
if (parentDto is null)
{
parentDto = new AncestralTagDto(parent.Id, parent.Name);
allTags.Add(parentDto);
}
parentDto.Children.Add(tag);
GetParents(parentDto);
}
}
else //the tag is a root tag, and should be in the root collection. If it's not in there, add it.
{
//this block could be simplified to just roots.Add(tag), but it's left this way for other logic.
var existingRoot = roots.SingleOrDefault(i => i.Equals(tag));
if (existingRoot is null)
roots.Add(tag);
}
}
关于加载子对象的示例，我将举一个评论对象的例子。每个评论都可能有一个子评论。
private static void LoadComments(<yourObject> q, Context yourContext)
{
if(null == q | null == yourContext)
{
return;
}
yourContext.Entry(q).Reference(x=> x.Comment).Load();
Comment curComment = q.Comment;
while(null != curComment)
{
curComment = LoadChildComment(curComment, yourContext);
}
}
private static Comment LoadChildComment(Comment c, Context yourContext)
{
if(null == c | null == yourContext)
{
return null;
}
yourContext.Entry(c).Reference(x=>x.ChildComment).Load();
return c.ChildComment;
}