如何在C#中基于客户端动态映射两个类的属性？

核心思路 #

通过数据库存储客户端专属的JSON映射规则，动态构建AutoMapper配置，避免硬编码ForMember逻辑。关键是将数据库中的映射规则反序列化为实体类，再循环生成AutoMapper的映射配置，并缓存Mapper实例提升性能。

步骤1：定义映射规则数据结构 #

先创建与数据库JSON映射对应的实体类，用于序列化/反序列化：

// 数据库存储的客户端映射规则实体
public class ClientMappingRule
{
    public string ClientId { get; set; }
    public string SourceTypeFullName { get; set; } // 例如 "AppA.Models.Employee"
    public string TargetTypeFullName { get; set; } // 例如 "AppB.Models.Employee"
    public List<FieldMapping> FieldMappings { get; set; } = new();
}

// 字段级映射规则
public class FieldMapping
{
    public string SourceFields { get; set; } // 单个字段如"Description"，多字段用分隔符如"FirstName|LastName"
    public string TargetField { get; set; }
}

数据库中可将ClientMappingRule序列化为JSON字符串存储（比如PostgreSQL用jsonb类型，SQL Server用NVARCHAR(MAX)）。

步骤2：实现动态Mapper服务 #

创建一个服务类，负责从数据库读取规则、动态构建AutoMapper配置并缓存实例：

public class DynamicMappingService
{
    private readonly IDictionary<string, IMapper> _mapperCache = new Dictionary<string, IMapper>();
    private readonly IMappingRuleRepository _mappingRuleRepo; // 自定义数据库仓储，用于读取映射规则

    public DynamicMappingService(IMappingRuleRepository mappingRuleRepo)
    {
        _mappingRuleRepo = mappingRuleRepo;
    }

    public IMapper GetMapperForClient(string clientId, Type sourceType, Type targetType)
    {
        // 生成缓存键，确保每个客户端+类型组合唯一
        var cacheKey = $"{clientId}_{sourceType.FullName}_{targetType.FullName}";
        if (_mapperCache.TryGetValue(cacheKey, out var mapper))
        {
            return mapper;
        }

        // 从数据库获取对应规则
        var mappingRule = _mappingRuleRepo.GetRule(clientId, sourceType.FullName, targetType.FullName);
        if (mappingRule == null)
        {
            throw new InvalidOperationException($"未找到客户端{clientId}在{sourceType.Name}与{targetType.Name}之间的映射规则");
        }

        // 动态构建AutoMapper配置
        var config = new MapperConfiguration(cfg =>
        {
            var map = cfg.CreateMap(sourceType, targetType);
            
            foreach (var fieldMap in mappingRule.FieldMappings)
            {
                var sourceFieldList = fieldMap.SourceFields.Split('|', StringSplitOptions.RemoveEmptyEntries);
                if (sourceFieldList.Length == 1)
                {
                    // 单字段直接映射
                    map.ForMember(fieldMap.TargetField, opt => opt.MapFrom(sourceFieldList[0]));
                }
                else
                {
                    // 多字段组合映射（如FirstName+LastName）
                    map.ForMember(fieldMap.TargetField, opt => opt.ResolveUsing(source =>
                    {
                        var fieldValues = sourceFieldList
                            .Select(field => source.GetType().GetProperty(field)?.GetValue(source)?.ToString() ?? string.Empty);
                        return string.Join(" ", fieldValues);
                    }));
                }
            }
        });

        // 开发阶段验证配置合法性（生产环境可关闭）
        config.AssertConfigurationIsValid();
        
        mapper = config.CreateMapper();
        _mapperCache[cacheKey] = mapper;
        return mapper;
    }

    // 封装泛型映射方法，简化调用
    public TTarget Map<TTarget>(string clientId, object source)
    {
        var sourceType = source.GetType();
        var targetType = typeof(TTarget);
        var mapper = GetMapperForClient(clientId, sourceType, targetType);
        return mapper.Map<TTarget>(source);
    }
}

步骤3：使用示例 #

假设已有应用A的Employee对象，调用服务完成映射：

// 示例：应用A的Employee对象
var appAEmployee = new AppA.Models.Employee
{
    FirstName = "John",
    LastName = "Doe",
    Description = "高级开发工程师",
    Title = "技术负责人"
};

// 从DI容器获取映射服务
var mappingService = serviceProvider.GetService<DynamicMappingService>();
// 客户端A的映射：Name=FirstName+LastName，Title=Description，JobTitle=Title
var appBEmployee = mappingService.Map<AppB.Models.Employee>("ClientA", appAEmployee);

关键注意事项 #

• 缓存优化：Mapper实例缓存是必须的，因为每次创建MapperConfiguration是高开销操作，复用缓存能大幅提升性能。
• 复杂映射扩展：如果需要自定义转换逻辑（比如类型转换、格式化），可以在FieldMapping中新增TransformLogic字段存储表达式字符串，通过表达式树动态编译执行（需注意安全性）。
• 错误处理：需添加源字段不存在、类型不匹配的异常捕获，避免映射失败导致崩溃。
• 替代方案：如果AutoMapper过于重量级，也可以直接用反射实现映射——遍历目标对象的属性，根据映射规则从源对象读取对应字段值或组合值，这种方式更轻量但需要手动处理更多细节。

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