N层项目中泛型仓储如何用AutoMapper转换实体与领域模型？

首先先明确你的项目结构：

• App.Model - 包含实体模型（entity models）
• App.Repo - 包含泛型仓储（generic repository）
• App.Domain - 包含业务对象（Business objects）
• App.Services - 包含服务（Services）

你提到非泛型场景下可以用Mapper.Map<MyDomainModel>(MyEntityModel)完成转换，但在泛型仓储里不知道怎么处理，针对这个问题，我给你几个实用的解决方案：

方案1：利用AutoMapper的泛型映射能力 #

AutoMapper本身就支持泛型转换，只要你提前配置好实体与领域模型的映射规则，就可以在泛型仓储中直接调用泛版的Map方法。

首先确保你的仓储注入了IMapper实例，然后修改GetById方法：

public class Repository<TEntity,TDomain> : IRepository<TEntity> where TEntity : class 
{ 
    private readonly IMapper _mapper;
    private readonly DbContext _db;

    // 通过构造函数注入依赖
    public Repository(DbContext db, IMapper mapper)
    {
        _db = db;
        _mapper = mapper;
    }

    public TDomain GetById(int id) 
    { 
        var entity = _db.Set<TEntity>().Find(id);
        // 直接用泛型Map方法转换
        return _mapper.Map<TDomain>(entity);
    } 
}

关键前提：你需要在AutoMapper的配置文件中注册所有TEntity到TDomain的映射，比如：

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<UserEntity, UserDomain>();
        CreateMap<OrderEntity, OrderDomain>();
        // 其他实体与领域模型的映射规则
    }
}

这种方法是最常用的，因为AutoMapper会帮你处理大部分常规的属性映射，减少重复代码。

方案2：自定义转换接口+泛型约束 #

如果不想依赖第三方库，你可以自己定义一个转换接口，让领域模型实现从实体转换的逻辑，然后通过泛型约束强制TDomain实现这个接口。

第一步，定义转换接口：

public interface IFromEntityConverter<TEntity>
{
    void ConvertFrom(TEntity entity);
}

第二步，让你的领域模型实现这个接口：

public class UserDomain : IFromEntityConverter<UserEntity>
{
    public int Id { get; set; }
    public string Username { get; set; }

    public void ConvertFrom(UserEntity entity)
    {
        Id = entity.Id;
        Username = entity.UserName;
        // 自定义其他属性的转换逻辑
    }
}

第三步，修改泛型仓储的约束和实现：

public class Repository<TEntity,TDomain> : IRepository<TEntity> 
    where TEntity : class 
    where TDomain : IFromEntityConverter<TEntity>, new() // 新增约束，要求TDomain有无参构造
{ 
    private readonly DbContext _db;

    public Repository(DbContext db)
    {
        _db = db;
    }

    public TDomain GetById(int id) 
    { 
        var entity = _db.Set<TEntity>().Find(id);
        var domainModel = new TDomain();
        domainModel.ConvertFrom(entity);
        return domainModel;
    } 
}

这种方法完全自主控制转换逻辑，没有第三方依赖，但每个领域模型都要写转换代码，适合对映射逻辑有特殊要求的场景。

方案3：注入转换委托实现灵活映射 #

如果有些模型的转换逻辑比较特殊，或者不想用接口约束，你可以在仓储构造时注入一个转换委托，这样能灵活定制每个仓储的转换逻辑。

修改仓储代码：

public class Repository<TEntity,TDomain> : IRepository<TEntity> where TEntity : class 
{ 
    private readonly DbContext _db;
    private readonly Func<TEntity, TDomain> _entityToDomainConverter;

    // 注入转换委托
    public Repository(DbContext db, Func<TEntity, TDomain> entityToDomainConverter)
    {
        _db = db;
        _entityToDomainConverter = entityToDomainConverter;
    }

    public TDomain GetById(int id) 
    { 
        var entity = _db.Set<TEntity>().Find(id);
        return _entityToDomainConverter(entity);
    } 
}

在依赖注入容器中注册仓储时，传入对应的转换逻辑：

// 示例：用AutoMapper作为转换逻辑
services.AddScoped<Repository<UserEntity, UserDomain>>(sp => 
    new Repository<UserEntity, UserDomain>(
        sp.GetRequiredService<DbContext>(),
        entity => sp.GetRequiredService<IMapper>().Map<UserDomain>(entity)
    )
);

// 或者自定义转换逻辑
services.AddScoped<Repository<OrderEntity, OrderDomain>>(sp => 
    new Repository<OrderEntity, OrderDomain>(
        sp.GetRequiredService<DbContext>(),
        entity => new OrderDomain { 
            Id = entity.Id, 
            TotalAmount = entity.Amount * entity.TaxRate 
        }
    )
);

这种方案灵活性最高，能应对各种特殊的转换场景，但需要手动配置每个仓储的转换委托，适合小项目或者有特殊映射需求的场景。

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