包括所有具有递归属性EF Core的导航属性

Question

我尝试过急地加载与实体相关的所有数据，但是对于像这样的可追溯属性仍然存在问题：

  public class Node : BaseAbstractEntity
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }


    [ForeignKey("TypeId")]
    public virtual NodeType Type { get; set; }
    public int? TypeId { get; set; }


    [ForeignKey("ParentId")]
    public virtual Node Parent { get; set; }
    public int? ParentId { get; set; }


    public ICollection<Node> Children { get; set; }
}

我正在这种方法中使用它：

 public async Task<object> JustGetAsync(Type type, JObject value, DbContext context)
    {
        int id = 0;
        if (value != null && value["id"] != null)
            id = Int32.Parse(value["id"].ToString());

        if (id != 0)
            return await context.FindAsync(type, id);

        var TypeSet = (IQueryable<object>) context.GetType()
                                                  .GetMethod("Set")
                                                  .MakeGenericMethod(type)
                                                  .Invoke(context, null);

        return await TypeSet.Include(context.GetIncludePaths(type)).ToListAsync();
    }

get IncludePaths是我在enter link description here处找到的代码，可帮助渴望所有属性：

公共静态IQueryable Include（此IQueryable源，IEnumerable navigationPropertyPaths）             其中T：类         {             返回navigationPropertyPaths.Aggregate（source，（query，path）=> query.Include（path））;         }

    public static IEnumerable<string> GetIncludePaths(this DbContext context, Type clrEntityType)
    {
        var entityType = context.Model.FindEntityType(clrEntityType);
        var includedNavigations = new HashSet<INavigation>();
        var stack = new Stack<IEnumerator<INavigation>>();
        while (true)
        {
            var entityNavigations = new List<INavigation>();
            foreach (var navigation in entityType.GetNavigations())
            {
                if (includedNavigations.Add(navigation))
                    entityNavigations.Add(navigation);
            }
            if (entityNavigations.Count == 0)
            {
                if (stack.Count > 0)
                    yield return string.Join(".", stack.Reverse().Select(e => e.Current.Name));
            }
            else
            {
                foreach (var navigation in entityNavigations)
                {
                    var inverseNavigation = navigation.FindInverse();
                    if (inverseNavigation != null)
                        includedNavigations.Add(inverseNavigation);
                }
                stack.Push(entityNavigations.GetEnumerator());
            }
            while (stack.Count > 0 && !stack.Peek().MoveNext())
                stack.Pop();
            if (stack.Count == 0) break;
            entityType = stack.Peek().Current.GetTargetType();
        }
    }