如何无需逐个指定Include查询Foo的全层级关联子元素？

针对你的需求——不用手动写Include/ThenInclude多层嵌套，同时获取级联删除关联实体做撤销机制，这里有几种可行方案：

1. 启用全局延迟加载 #

你的实体已经把导航属性标记为virtual，可以直接在DbContext里开启延迟加载代理，这样访问任意层级的导航属性时，EF会自动去数据库加载关联数据：

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer("你的连接字符串")
        .UseLazyLoadingProxies();
}

⚠️ 注意：这种方式会引发N+1查询问题，而且如果实体间存在循环引用（比如Cat关联回Bar），序列化时会报错，需要在序列化配置里忽略循环引用（比如Json.NET设置ReferenceLoopHandling.Ignore）。如果只是简单场景可以用，但对于级联删除元素收集的需求，效率可能不够高。

2. 递归Include扩展方法（处理循环引用） #

自己写一个扩展方法，递归遍历实体的所有导航属性，自动生成Include/ThenInclude，同时用集合记录已经处理过的实体类型，避免循环递归：

public static class QueryExtensions
{
    public static IQueryable<TEntity> IncludeAll<TEntity>(this IQueryable<TEntity> query, HashSet<Type> includedTypes = null)
        where TEntity : class
    {
        includedTypes ??= new HashSet<Type>();
        var entityType = typeof(TEntity);
        
        if (includedTypes.Contains(entityType))
            return query;
        
        includedTypes.Add(entityType);
        
        // 筛选出所有集合或实体类型的导航属性（排除string）
        var navigationProps = entityType.GetProperties()
            .Where(p => 
                (p.PropertyType.IsGenericType && typeof(ICollection<>).IsAssignableFrom(p.PropertyType.GetGenericTypeDefinition()))
                || (p.PropertyType.IsClass && p.PropertyType != typeof(string)));
        
        foreach (var prop in navigationProps)
        {
            // 构建Include表达式
            var param = Expression.Parameter(entityType, "x");
            var propAccess = Expression.Property(param, prop);
            var includeExpr = Expression.Lambda(propAccess, param);
            
            query = query.Include(includeExpr);
            
            // 获取导航属性对应的实体类型
            var navEntityType = prop.PropertyType.IsGenericType 
                ? prop.PropertyType.GetGenericArguments()[0] 
                : prop.PropertyType;
            
            // 处理集合类型的ThenInclude，并递归调用IncludeAll
            if (typeof(ICollection<>).IsAssignableFrom(prop.PropertyType.GetGenericTypeDefinition()))
            {
                var thenIncludeMethod = typeof(EntityFrameworkQueryableExtensions)
                    .GetMethods()
                    .First(m => m.Name == "ThenInclude" && m.GetParameters().Length == 2)
                    .MakeGenericMethod(entityType, navEntityType);
                
                var thenIncludeParam = Expression.Parameter(navEntityType, "x");
                var thenIncludeLambda = Expression.Lambda(thenIncludeParam, thenIncludeParam);
                query = (IQueryable<TEntity>)thenIncludeMethod.Invoke(null, new object[] { query, thenIncludeLambda });
                
                // 递归处理关联实体的所有导航属性
                var includeAllMethod = typeof(QueryExtensions)
                    .GetMethod(nameof(IncludeAll))
                    .MakeGenericMethod(navEntityType);
                
                query = (IQueryable<TEntity>)includeAllMethod.Invoke(null, new object[] { query, includedTypes });
            }
            else
            {
                // 处理单个实体类型的导航属性
                var includeAllMethod = typeof(QueryExtensions)
                    .GetMethod(nameof(IncludeAll))
                    .MakeGenericMethod(navEntityType);
                
                query = (IQueryable<TEntity>)includeAllMethod.Invoke(null, new object[] { query, includedTypes });
            }
        }
        
        return query;
    }
}

使用时直接调用：

var fullFoo = dbContext.Foos.IncludeAll().FirstOrDefault(f => f.Id == targetId);

这个方法通过includedTypes集合避免循环引用导致的无限递归，一次性加载所有层级的关联实体。

3. 针对级联删除场景的最优方案：用ChangeTracker收集实体 #

因为你的核心需求是获取级联删除时会被删除的元素，没必要加载所有关联实体，直接利用EF的ChangeTracker来跟踪这些实体更高效：

public List<object> GetCascadeDeleteTargets(Foo targetFoo)
{
    var deletedEntities = new List<object>();
    var visited = new HashSet<object>(); // 避免循环引用重复收集
    
    void CollectCascadeEntities(object entity)
    {
        if (entity == null || visited.Contains(entity))
            return;
        
        visited.Add(entity);
        deletedEntities.Add(entity);
        
        var entry = _dbContext.Entry(entity);
        // 遍历所有导航属性
        foreach (var nav in entry.Navigations)
        {
            var foreignKey = nav.Metadata.ForeignKey;
            // 只收集配置了级联删除的关联实体
            if (foreignKey.DeleteBehavior != DeleteBehavior.Cascade)
                continue;
            
            if (nav.Metadata.IsCollection())
            {
                var collection = nav.CurrentValue as IEnumerable<object>;
                if (collection != null)
                {
                    foreach (var item in collection)
                    {
                        CollectCascadeEntities(item);
                    }
                }
            }
            else
            {
                var relatedEntity = nav.CurrentValue;
                CollectCascadeEntities(relatedEntity);
            }
        }
    }
    
    // 附加实体并标记为删除，触发ChangeTracker跟踪级联关系
    _dbContext.Foos.Attach(targetFoo);
    _dbContext.Entry(targetFoo).State = EntityState.Deleted;
    
    CollectCascadeEntities(targetFoo);
    
    // 恢复实体状态，避免误删除
    _dbContext.Entry(targetFoo).State = EntityState.Unchanged;
    
    return deletedEntities;
}

这个方法的好处：

• 只收集真正会被级联删除的实体（根据你的EF删除行为配置），无关关联不会被加载
• 通过visited集合自动处理循环引用
• 不需要提前加载任何关联，性能更优，完全匹配你的撤销机制需求

内容的提问来源于stack exchange，提问作者anthonymp13