如何在EF Core 7中判断泛型实体是否存在外键引用？

问题简述 #

是否可以通过Entity Framework Core 7（EF Core 7）判断泛型实体是否存在外键（Foreign Key，FK）引用？换句话说，能否通过EF Core 7判断删除某实体是否会因外键引用约束违规而失败（假设所有外键引用均未设置级联删除）？

详细背景 #

运营一个销售部件（widgets）的网站，使用SQL数据库并通过EF Core 7访问。数据库中有若干存储不常变更信息的表（如部件描述、税目表等），这些表被订单、物流、产品支持等诸多其他表引用。若其他表中存在对这些“不常变更”表数据的外键引用，对应数据行无法被删除——比如物流表显示某类部件正在运往奥马哈的途中，该部件就不能删除。

更新部件列表（或其他“不常变更”表）时，会调用泛型函数UpdateDatabase<TEntity>，传入最新实体列表，按需执行新增、更新或删除操作：

public async Task UpdateDatabase<TEntity>(List<TEntity> newItems)
    where TEntity : IEntityInfo, class
{
    <...>
}

函数会从数据库获取现有<TEntity>实体，通过<IEntityInfo>接口的属性与newItems对比，执行相应操作。

新增或修改操作没问题，但删除时存在问题：若现有实体存在外键引用，删除会触发DbUpdateException，此时实体在DbContext中状态为EntityState.Deleted但数据库中仍存在，后续调用UpdateDatabase()都会失败。

需要找到泛型实体是否可被删除的判断方法（所有外键均为限制删除），现有两个可选方案：

• 首选方案：通过EF Core判断泛型实体是否存在外键引用
• 备选方案：在<IEntityInfo>中添加CanBeDeleted()方法，由每个实体类自行实现，但该方案脆弱——新增外键引用时需同步更新方法。

一、首选方案：利用EF Core元数据+动态查询判断引用 #

EF Core的元数据系统可以自动获取实体的所有被引用外键关系，结合动态表达式树实现泛型的引用检查，无需手动维护外键关联逻辑。

1. 获取实体的被引用外键信息 #

通过DbContext.Model获取目标实体的元数据，筛选出所有指向该实体的外键（即其他实体中引用当前实体的外键）：

private IEnumerable<IReadOnlyForeignKey> GetReferencingForeignKeys<TEntity>(DbContext context)
{
    var targetEntityType = context.Model.FindEntityType(typeof(TEntity));
    return context.Model.GetEntityTypes()
        .SelectMany(entityType => entityType.GetForeignKeys())
        .Where(fk => fk.PrincipalEntityType == targetEntityType);
}

2. 动态检查是否存在关联数据 #

对每个找到的外键，构建查询判断是否有对应的关联数据存在。通过表达式树动态生成查询条件，适配复合主键等场景：

public async Task<bool> HasReferencesAsync<TEntity>(DbContext context, TEntity entity)
    where TEntity : IEntityInfo, class
{
    var targetEntityType = context.Model.FindEntityType(typeof(TEntity));
    var primaryKey = targetEntityType.FindPrimaryKey();
    if (primaryKey == null) return false;

    var referencingForeignKeys = GetReferencingForeignKeys<TEntity>(context);
    foreach (var fk in referencingForeignKeys)
    {
        var referencedDbSet = context.Set(fk.DeclaringEntityType.ClrType);
        var parameter = Expression.Parameter(fk.DeclaringEntityType.ClrType, "entity");
        Expression predicate = null;

        // 构建外键与主键的匹配条件
        for (int i = 0; i < fk.Properties.Count; i++)
        {
            var fkProperty = fk.Properties[i];
            var pkProperty = primaryKey.Properties[i];
            var fkPropertyAccess = Expression.Property(parameter, fkProperty.Name);
            var pkValue = pkProperty.GetGetter().GetClrValue(entity);
            var constantValue = Expression.Constant(pkValue, pkProperty.ClrType);
            var equalsExpression = Expression.Equal(fkPropertyAccess, constantValue);

            predicate = predicate == null ? equalsExpression : Expression.AndAlso(predicate, equalsExpression);
        }

        // 生成Count查询并执行
        var countMethod = typeof(Queryable).GetMethod("Count", new[] { typeof(IQueryable<>), typeof(Expression<Func<,>>) })
                                           .MakeGenericMethod(fk.DeclaringEntityType.ClrType);
        var count = (int)await referencedDbSet.AsQueryable().Provider.ExecuteAsync(
            Expression.Call(countMethod, referencedDbSet.AsQueryable().Expression, Expression.Lambda(predicate, parameter)));

        if (count > 0) return true;
    }
    return false;
}

3. 在泛型函数中集成判断 #

在UpdateDatabase<TEntity>中，删除前先调用HasReferencesAsync确认是否可删除：

public async Task UpdateDatabase<TEntity>(List<TEntity> newItems)
    where TEntity : IEntityInfo, class
{
    var existingItems = await Context.Set<TEntity>().ToListAsync();
    foreach (var existing in existingItems)
    {
        if (!newItems.Any(n => n.Id == existing.Id)) // 假设IEntityInfo包含Id属性
        {
            if (!await HasReferencesAsync(Context, existing))
            {
                Context.Remove(existing);
            }
            else
            {
                // 处理无法删除的逻辑：如记录日志、标记实体为禁用等
            }
        }
    }

    // 处理新增、更新逻辑
    await Context.SaveChangesAsync();
}

该方案的核心优势是自动适配数据库结构变更，新增外键引用时无需修改代码，完全依赖EF Core元数据驱动。

二、备选方案：改进实体类的可删除判断逻辑 #

如果动态查询的性能不符合需求，可以优化备选方案，降低其脆弱性：

1. 定义统一的可删除检查接口 #

创建独立接口替代直接在IEntityInfo中添加方法，职责更清晰：

public interface IDeletable
{
    Task<bool> CanBeDeletedAsync(DbContext context);
}

2. 实体类通过导航属性实现检查 #

每个实体类实现CanBeDeletedAsync时，直接利用EF Core的导航属性查询关联数据，避免硬编码表名：

public class Widget : IEntityInfo, IDeletable
{
    public int Id { get; set; }
    public ICollection<Order> Orders { get; set; }
    public ICollection<Shipment> Shipments { get; set; }

    public async Task<bool> CanBeDeletedAsync(DbContext context)
    {
        var widget = await context.Set<Widget>()
            .Include(w => w.Orders)
            .Include(w => w.Shipments)
            .FirstOrDefaultAsync(w => w.Id == Id);
        
        return widget != null && widget.Orders.Count == 0 && widget.Shipments.Count == 0;
    }
}

3. 泛型函数中调用检查逻辑 #

在UpdateDatabase<TEntity>中，判断实体是否实现IDeletable接口并执行检查：

public async Task UpdateDatabase<TEntity>(List<TEntity> newItems)
    where TEntity : IEntityInfo, class
{
    var existingItems = await Context.Set<TEntity>().ToListAsync();
    foreach (var existing in existingItems)
    {
        if (!newItems.Any(n => n.Id == existing.Id))
        {
            bool canDelete = true;
            if (existing is IDeletable deletable)
            {
                canDelete = await deletable.CanBeDeletedAsync(Context);
            }
            
            if (canDelete)
            {
                Context.Remove(existing);
            }
            else
            {
                // 处理无法删除的逻辑
            }
        }
    }
    await Context.SaveChangesAsync();
}

该方案的优势是查询更精准，可针对特定实体优化查询逻辑，但需要在新增外键引用时同步更新对应实体类的CanBeDeletedAsync方法。

内容的提问来源于stack exchange，提问作者Bob.at.Indigo.Health