EF Core 6 not loading child entities - entity-framework-core

Question

I am working on a simple web API that is just supposed to parse a JSON tree, and save it to a database. I am working with EF Core 6.0.4 and my application shows a really weird behaviour: right after saving the tree, it loads from the context just fine. But when I call a different endpoint and load the data using a freshly initialized context, the children won't load. I believe it's due to the EF config, but I can't figure out how to load the children.
I tried using _context.Entity(returnValue).Collection(x => x.Children) but the x in the lambda only has ICollection extension methods, not the model fields like in the code examples I saw.
I also tried using .Include, but that seems to be a thing from regular EF.
Here's some of my code:
Controller
public class CategoryTreeManagerController : ControllerBase
{
private readonly CategoryTreeManagerService _service;
public CategoryTreeManagerController(CategoryTreeManagerService service)
{
_service = service;
}
[HttpGet]
public IEnumerable<CategoryTreeNode> GetTree()
{
return _service.GetTree(); //this only returns the root node without any children
}
[HttpPost]
public IEnumerable<CategoryTreeNode> SaveTree(CategoryTreeNode[] nodes)
{
_service.SaveTree(nodes[0]);
return _service.GetTree(); //this correctly returns the tree
}
}
Service
public class CategoryTreeManagerService
{
private readonly CategoryTreeManagerApiDbContext _context;
public CategoryTreeManagerService(CategoryTreeManagerApiDbContext context)
{
_context = context;
}
public IEnumerable<CategoryTreeNode> GetTree()
{
CategoryTreeNode[] returnValue = _context.CategoryTreeNodes
.Where(x => x.Parent == null) //just return the root node
.ToArray(); //easier for frontend
return returnValue;
}
public void SaveTree(CategoryTreeNode node)
{
if (_context.CategoryTreeNodes.Any(x => x.Id == node.Id))
{
_context.Update(node);
}
else
{
_context.CategoryTreeNodes.Add(node);
}
_context.SaveChanges();
}
}
DbContext
public class CategoryTreeManagerApiDbContext : DbContext
{
public CategoryTreeManagerApiDbContext() : base ()
{
Database.EnsureCreated();
}
public CategoryTreeManagerApiDbContext(DbContextOptions<CategoryTreeManagerApiDbContext> options) : base(options)
{
Database.EnsureCreated();
}
public DbSet<CategoryTreeNode> CategoryTreeNodes { get; set; }
public DbSet<TreeNodeDetail> TreeNodeDetails { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<CategoryTreeNode>(entity =>
{
entity.HasKey(x => x.Id);
entity.HasOne(x => x.Parent)
.WithMany(x => x.Children)
.IsRequired(false)
.OnDelete(DeleteBehavior.Restrict);
});
}
Model classes
public class CategoryTreeNode
{
public int Id { get; set; }
public string Label { get; set; }
public string Story { get; set; }
public string Icon { get; set; }
public ICollection<TreeNodeDetail> Details { get; set; }
public ICollection<CategoryTreeNode> Children { get; set; }
[JsonIgnore]
public CategoryTreeNode? Parent { get; set; }
}
public class TreeNodeDetail
{
[JsonPropertyName("detailId")]
public string Id { get; set; }
[JsonPropertyName("detailTitle")]
public string Title { get; set; }
[JsonPropertyName("detailValue")]
public string Value { get; set; }
[JsonIgnore]
[ForeignKey("CategoryTreeNode")]
public int CategoryTreeNodeId { get; set; }
}

Answer 1

Include would work for one level, or more if you expand out the expression, but it's not an ideal solution for tree structures which could be variable depth. (I.e. child of a child of a child ...)
For instance:
CategoryTreeNode[] returnValue = _context.CategoryTreeNodes
.Include(x => x.Children)
.Where(x => x.Parent == null) //just return the root node
.ToArray(); //easier for frontend
would load all parents and their first level children. To load 2nd level children:
CategoryTreeNode[] returnValue = _context.CategoryTreeNodes
.Include(x => x.Children)
.ThenInclude(x => x.Children)
.Where(x => x.Parent == null) //just return the root node
.ToArray(); //easier for frontend
The issue is knowing how many levels to load, and each level produces a Cartesian Product for EF to work through, exponentially increasing the amount of data being loaded to build a tree. Loading an entire table once quickly becomes a much more efficient solution.
If you have a Single tree structure where you expect only one top-level entry, or want to load an entire reasonable set of top-level nodes then loading all entries into memory will work since EF will be tracking all of the entities and it can resolve all of the various references as it builds the entity structure. This has to load the entire set even if you only want one specific parent out of several possible parents.
If you have several top level parent nodes and a sizeable overall table size to work through, and do want to be able to load a single parent and it's children then one option is to add a de-normalized top-level ID reference to the tree node.
public int Id { get; set; }
public int? TopLevelId { get; set; }
This would be a null-able FK but does not need a navigation property. The current Parent reference would continue to use a shadow property. (I.e. ParentId) In this way once you have an ID for the top-level parent you want to load a tree for:
_context.CategoryTreeNodes.Where(x => x.TopLevelId == topLevelId).ToList();
var topLevelNode = _context.CategoryTreeNodes.Single(x => x.Id == topLevelId);
The first statement will have the DBContext load and track all nodes under that top level tree node. Then when you call the DbContext to get that top level node, the tracked related entities will all get filled in.
The caveat of this approach is that it is a denormalization, in that there is no DB-level assertion that a TopLevelId is set, or remains set correctly. For instance if nodes can be moved between top-level entities and you forget to update this value, this node would not be loaded and associated under the new parent using the above load.