如何在EF Core中实现多列值映射到实体的字典属性

我有一款未使用Entity Framework的本地部署应用，每个客户拥有独立的安装实例和SQL Server数据库实例。所有数据库的多数表和列保持一致，但客户可以添加仅存在于自身数据库实例的自定义列。

举个简单例子：标准数据库包含Employee表，列有Id、Number、Name。客户1新增了Role列，客户2新增了StartDate和EndDate列。

客户1的Employee表 #

客户2的Employee表 #

在未使用EF的情况下，我的类模型包含标准属性与存储该记录所有自定义列数据的字典（键：列名，值：列值），如下所示：

public int Id { get; set; }
public string Number { get; set; }
public string Name { get; set; }
public Dictionary<string, object> CustomFields { get; set; }

客户1的Employee读取示例 #

Id: 1
Number: 15
Name: John
CustomFields: ["Role", "Office administrator"]

Id: 2
Number: 12
Name: Paul
CustomFields: ["Role", "Office manager"]

客户2的Employee读取示例 #

Id: 1
Number: 8
Name: Mark
CustomFields: ["StartDate", "2024-01-01"], ["EndDate", "2024-12-31"]

Id: 2
Number: 17
Name: Jack
CustomFields: ["StartDate", "2023-07-01"], ["EndDate", "2024-12-31"]

需求 #

如何在EF Core中实现该功能？

我尝试过一些方案但均无效：

• 继承方式处理未定义在模型中的列
• 影子或索引器属性

期望找到可自动生效的配置（或许在OnModelCreating中？）。数据库包含数百张表，无法逐个处理查询。

要实现自动将数据库中的自定义列映射到实体的CustomFields字典，且无需逐个表配置，可以通过以下方式实现：

1. 定义通用实体基类 #

先创建包含CustomFields字典的基类，让所有需要支持自定义列的实体继承它：

public abstract class BaseEntity
{
    public Dictionary<string, object> CustomFields { get; set; } = new Dictionary<string, object>();
}

// 示例实体
public class Employee : BaseEntity
{
    public int Id { get; set; }
    public string Number { get; set; }
    public string Name { get; set; }
}

2. 用EF Core拦截器自动加载自定义列 #

通过实现查询拦截器，自动识别数据库中的自定义列并添加到查询中，再将结果填充到CustomFields字典。

步骤1：实现查询拦截器 #

public class CustomFieldQueryInterceptor : IQueryInterceptor
{
    private readonly Dictionary<Type, List<string>> _customColumnsCache;

    public CustomFieldQueryInterceptor(Dictionary<Type, List<string>> customColumnsCache)
    {
        _customColumnsCache = customColumnsCache;
    }

    public ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(
        DbCommand command,
        CommandEventData eventData,
        InterceptionResult<DbDataReader> result,
        CancellationToken cancellationToken = default)
    {
        var entityType = GetTargetEntityType(command, eventData.Context);
        if (entityType == null)
            return ValueTask.FromResult(result);

        // 缓存自定义列，避免重复读取数据库架构
        if (!_customColumnsCache.TryGetValue(entityType.ClrType, out var customColumns))
        {
            customColumns = FetchCustomColumns(entityType, eventData.Context);
            _customColumnsCache[entityType.ClrType] = customColumns;
        }

        // 修改SQL查询，添加自定义列
        if (customColumns.Any())
        {
            var columnStr = string.Join(", ", customColumns.Select(c => $"[{c}]"));
            var originalSql = command.CommandText;
            var fromIndex = originalSql.IndexOf(" FROM ", StringComparison.OrdinalIgnoreCase);
            if (fromIndex != -1)
            {
                command.CommandText = $"{originalSql.Substring(0, fromIndex)}, {columnStr}{originalSql.Substring(fromIndex)}";
            }
        }

        return ValueTask.FromResult(result);
    }

    // 从查询中解析目标实体类型
    private IEntityType? GetTargetEntityType(DbCommand command, DbContext? context)
    {
        if (context == null) return null;
        var tableName = ExtractTableName(command.CommandText);
        return string.IsNullOrEmpty(tableName) 
            ? null 
            : context.Model.GetEntityTypes()
                .FirstOrDefault(t => t.GetTableName()?.Equals(tableName, StringComparison.OrdinalIgnoreCase) == true);
    }

    // 获取数据库中表的自定义列（排除模型已定义的列）
    private List<string> FetchCustomColumns(IEntityType entityType, DbContext context)
    {
        var tableName = entityType.GetTableName();
        if (tableName == null) return new List<string>();

        var connection = context.Database.GetDbConnection();
        connection.Open();
        var allColumns = new List<string>();

        using (var cmd = connection.CreateCommand())
        {
            cmd.CommandText = $"SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '{tableName}'";
            using (var reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    allColumns.Add(reader.GetString(0));
                }
            }
        }
        connection.Close();

        var definedColumns = entityType.GetProperties()
            .Select(p => p.GetColumnName())
            .ToList();

        return allColumns.Except(definedColumns, StringComparer.OrdinalIgnoreCase).ToList();
    }

    // 简单提取SQL中的表名（复杂查询需用专业SQL解析库）
    private string? ExtractTableName(string sql)
    {
        var fromIndex = sql.IndexOf(" FROM ", StringComparison.OrdinalIgnoreCase);
        if (fromIndex == -1) return null;
        var afterFrom = sql.Substring(fromIndex + 6).Trim();
        var spaceIndex = afterFrom.IndexOf(' ');
        return spaceIndex == -1 ? afterFrom : afterFrom.Substring(0, spaceIndex);
    }
}

步骤2：实现实体加载后的映射逻辑 #

在DbContext的OnModelCreating中注册实体加载事件，将查询返回的自定义列值填充到CustomFields：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    foreach (var entityType in modelBuilder.Model.GetEntityTypes())
    {
        if (typeof(BaseEntity).IsAssignableFrom(entityType.ClrType))
        {
            modelBuilder.Entity(entityType.ClrType)
                .HasAnnotation("CustomColumnSupport", true);

            // 实体加载完成后填充自定义字段
            entityType.GetOrAddRuntimeAnnotation("PostMaterialize",
                (Action<object>)((entity) =>
                {
                    var baseEntity = entity as BaseEntity;
                    if (baseEntity == null) return;

                    var entry = Entry(entity);
                    if (_customColumnsCache.TryGetValue(entityType.ClrType, out var customColumns))
                    {
                        foreach (var column in customColumns)
                        {
                            var value = entry.Property(column).CurrentValue;
                            if (value != null)
                            {
                                baseEntity.CustomFields[column] = value;
                            }
                        }
                    }
                }));
        }
    }
}

步骤3：注册拦截器与缓存 #

在DbContext的OnConfiguring中注册拦截器，确保查询和映射共享同一缓存：

private readonly Dictionary<Type, List<string>> _customColumnsCache = new Dictionary<Type, List<string>>();

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

3. 支持自定义列写入 #

如果需要将CustomFields中的值写回数据库，实现保存拦截器：

public class CustomFieldSaveInterceptor : SaveChangesInterceptor
{
    private readonly Dictionary<Type, List<string>> _customColumnsCache;

    public CustomFieldSaveInterceptor(Dictionary<Type, List<string>> customColumnsCache)
    {
        _customColumnsCache = customColumnsCache;
    }

    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData,
        InterceptionResult<int> result,
        CancellationToken cancellationToken = default)
    {
        var context = eventData.Context;
        if (context == null) return base.SavingChangesAsync(eventData, result, cancellationToken);

        foreach (var entry in context.ChangeTracker.Entries<BaseEntity>())
        {
            if (entry.State is EntityState.Added or EntityState.Modified)
            {
                if (_customColumnsCache.TryGetValue(entry.Entity.GetType(), out var customColumns))
                {
                    foreach (var column in customColumns)
                    {
                        if (entry.Entity.CustomFields.TryGetValue(column, out var value))
                        {
                            entry.Property(column).CurrentValue = value;
                        }
                    }
                }
            }
        }

        return base.SavingChangesAsync(eventData, result, cancellationToken);
    }
}

将保存拦截器也注册到DbContext：

optionsBuilder
    .UseSqlServer("你的连接字符串")
    .AddInterceptors(
        new CustomFieldQueryInterceptor(_customColumnsCache),
        new CustomFieldSaveInterceptor(_customColumnsCache));

关键说明 #

• 缓存优化：自定义列信息仅在首次查询时读取数据库架构，后续直接使用缓存，避免重复IO
• SQL适配：示例中的SQL解析为简单实现，复杂查询（如JOIN、子查询）建议使用SqlKata等专业SQL解析库完善逻辑
• 类型兼容：需确保自定义列的数据库类型与CustomFields中存储的.NET类型匹配，可在拦截器中添加类型转换逻辑
• 批量生效：通过遍历所有实体类型实现自动配置，无需逐个表处理

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