C# AutoMapper对象映射详解

于 2025-05-23 09:12:11 发布
阅读量1k 收藏 28
点赞数 29
CC 4.0 BY-SA版权
分类专栏： C# 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/exlink2012/article/details/148155604

引言

在现代软件开发中，特别是采用分层架构的应用程序，我们经常需要在不同的对象类型之间进行转换。例如，从数据库实体（Entity）转换为数据传输对象（DTO），或者从视图模型（ViewModel）转换为领域模型（Domain Model）。手动编写这些转换代码不仅繁琐，还容易出错。这就是 AutoMapper 这类对象映射工具的价值所在。

本文将详细介绍 C# 中 AutoMapper 的使用方法、最佳实践以及一些高级特性，帮助你在项目中高效地实现对象映射。

什么是 AutoMapper？

AutoMapper 是一个简单、实用的 .NET 对象映射工具，它可以自动将一个对象的属性值复制到另一个对象中，从而消除了手动编写重复的对象转换代码的需要。

AutoMapper 的核心理念是约定大于配置，它会根据属性名称的匹配自动创建映射关系，同时也提供了丰富的配置选项来处理复杂的映射场景。

安装 AutoMapper

在开始使用 AutoMapper 之前，我们需要先安装它。使用 NuGet 包管理器可以轻松完成这一步：

# 使用 NuGet Package Manager Console
Install-Package AutoMapper

# 或者使用 .NET CLI
dotnet add package AutoMapper

对于 ASP.NET Core 应用程序，你可能还想安装 AutoMapper 的依赖注入扩展：

# 使用 NuGet Package Manager Console
Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

# 或者使用 .NET CLI
dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection

基本使用

创建映射配置

使用 AutoMapper 的第一步是创建映射配置。以下是一个简单的例子：

using AutoMapper;

// 源类和目标类
public class Customer
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
}

public class CustomerDto
{
    public int Id { get; set; }
    public string FullName { get; set; }
    public string Email { get; set; }
}

// 创建映射配置
var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<Customer, CustomerDto>()
       .ForMember(dest => dest.FullName, 
                  opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"));
});

// 创建映射器实例
var mapper = config.CreateMapper();

执行映射

一旦配置好映射关系，就可以使用 mapper.Map<TDestination>(source) 方法执行映射：

// 创建源对象
var customer = new Customer
{
    Id = 1,
    FirstName = "John",
    LastName = "Doe",
    Email = "john.doe@example.com"
};

// 执行映射
var customerDto = mapper.Map<CustomerDto>(customer);

// 输出结果
Console.WriteLine($"Id: {customerDto.Id}");
Console.WriteLine($"FullName: {customerDto.FullName}");
Console.WriteLine($"Email: {customerDto.Email}");

输出结果：

Id: 1
FullName: John Doe
Email: john.doe@example.com

在 ASP.NET Core 中使用 AutoMapper

在 ASP.NET Core 应用程序中，我们可以利用依赖注入来简化 AutoMapper 的使用。

注册 AutoMapper 服务

在 Program.cs 或 Startup.cs 中注册 AutoMapper 服务：

// Program.cs in .NET 6+
var builder = WebApplication.CreateBuilder(args);

// 添加 AutoMapper 服务
builder.Services.AddAutoMapper(typeof(Program).Assembly);

// 或者指定包含配置文件的程序集
// builder.Services.AddAutoMapper(typeof(MappingProfile).Assembly);

var app = builder.Build();
// ...

创建映射配置文件

为了保持代码的整洁，我们通常会创建单独的映射配置文件：

using AutoMapper;

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        // 配置 Customer 到 CustomerDto 的映射
        CreateMap<Customer, CustomerDto>()
            .ForMember(dest => dest.FullName, 
                      opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"));
        
        // 可以在这里添加更多映射配置
    }
}

在控制器中使用 AutoMapper

通过依赖注入在控制器中使用 AutoMapper：

[ApiController]
[Route("api/[controller]")]
public class CustomersController : ControllerBase
{
    private readonly IMapper _mapper;
    private readonly ICustomerRepository _repository;

    public CustomersController(IMapper mapper, ICustomerRepository repository)
    {
        _mapper = mapper;
        _repository = repository;
    }

    [HttpGet("{id}")]
    public ActionResult<CustomerDto> GetCustomer(int id)
    {
        var customer = _repository.GetById(id);
        
        if (customer == null)
            return NotFound();
            
        return _mapper.Map<CustomerDto>(customer);
    }
    
    [HttpGet]
    public ActionResult<IEnumerable<CustomerDto>> GetAllCustomers()
    {
        var customers = _repository.GetAll();
        return Ok(_mapper.Map<IEnumerable<CustomerDto>>(customers));
    }
}

高级映射技巧

处理不同名称的属性

当源对象和目标对象的属性名称不同时，可以使用 ForMember 方法来指定映射关系：

CreateMap<Source, Destination>()
    .ForMember(dest => dest.DestinationProperty, 
               opt => opt.MapFrom(src => src.SourceProperty));

条件映射

有时我们只想在特定条件下执行映射：

CreateMap<Source, Destination>()
    .ForMember(dest => dest.Property, 
               opt => opt.Condition(src => src.SomeValue != null));

值转换器

对于需要进行复杂转换的情况，可以使用值转换器：

CreateMap<Source, Destination>()
    .ForMember(dest => dest.FormattedDate, 
               opt => opt.MapFrom(src => src.Date.ToString("yyyy-MM-dd")));

集合映射

AutoMapper 可以自动处理集合之间的映射：

// 源类和目标类
public class Order
{
    public int Id { get; set; }
    public List<OrderItem> Items { get; set; }
}

public class OrderDto
{
    public int Id { get; set; }
    public List<OrderItemDto> Items { get; set; }
}

// 映射配置
CreateMap<Order, OrderDto>();
CreateMap<OrderItem, OrderItemDto>();

// 使用
var orderDto = _mapper.Map<OrderDto>(order);

扁平化映射

当目标对象的属性需要从源对象的嵌套属性中获取值时，可以使用扁平化映射：

// 源类和目标类
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string ZipCode { get; set; }
}

public class CustomerViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public string ZipCode { get; set; }
}

// 映射配置
CreateMap<Customer, CustomerViewModel>()
    .ForMember(dest => dest.Street, opt => opt.MapFrom(src => src.Address.Street))
    .ForMember(dest => dest.City, opt => opt.MapFrom(src => src.Address.City))
    .ForMember(dest => dest.ZipCode, opt => opt.MapFrom(src => src.Address.ZipCode));

或者使用更简洁的方式：

CreateMap<Customer, CustomerViewModel>()
    .ForMember(dest => dest.Street, opt => opt.MapFrom(src => src.Address.Street))
    .ForMember(dest => dest.City, opt => opt.MapFrom(src => src.Address.City))
    .ForMember(dest => dest.ZipCode, opt => opt.MapFrom(src => src.Address.ZipCode));

自定义值解析器

对于更复杂的映射逻辑，可以创建自定义值解析器：

public class FullNameResolver : IValueResolver<Customer, CustomerDto, string>
{
    public string Resolve(Customer source, CustomerDto destination, string destMember, ResolutionContext context)
    {
        return $"{source.FirstName} {source.LastName}";
    }
}

// 在映射配置中使用
CreateMap<Customer, CustomerDto>()
    .ForMember(dest => dest.FullName, 
               opt => opt.MapFrom<FullNameResolver>());

忽略属性

有时我们不希望映射某些属性：

CreateMap<Source, Destination>()
    .ForMember(dest => dest.PropertyToIgnore, opt => opt.Ignore());

双向映射

如果需要在两个类型之间进行双向映射，可以使用 ReverseMap 方法：

CreateMap<Customer, CustomerDto>()
    .ForMember(dest => dest.FullName, 
               opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"))
    .ReverseMap()
    .ForMember(dest => dest.FirstName, 
               opt => opt.MapFrom(src => src.FullName.Split(' ')[0]))
    .ForMember(dest => dest.LastName, 
               opt => opt.MapFrom(src => src.FullName.Split(' ')[1]));

性能优化

编译映射

AutoMapper 提供了编译映射功能，可以显著提高映射性能：

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<Customer, CustomerDto>();
});

// 验证配置
config.AssertConfigurationIsValid();

// 编译映射
config.CompileMapping();

使用映射表达式

对于性能要求极高的场景，可以使用映射表达式：

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<Customer, CustomerDto>();
});

// 获取映射表达式
var customerDtoExpression = config.CreateMapper()
    .ConfigurationProvider
    .BuildExecutionPlan(typeof(Customer), typeof(CustomerDto));

// 在 LINQ 查询中使用
var customerDtos = dbContext.Customers
    .AsNoTracking()
    .ProjectTo<CustomerDto>(config)
    .ToList();

测试映射配置

确保映射配置正确是很重要的，AutoMapper 提供了验证配置的方法：

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<Customer, CustomerDto>();
});

// 验证所有映射配置
config.AssertConfigurationIsValid();

也可以编写单元测试来验证映射配置：

[Fact]
public void AutoMapper_Configuration_IsValid()
{
    var config = new MapperConfiguration(cfg => 
    {
        cfg.AddProfile<MappingProfile>();
    });
    
    config.AssertConfigurationIsValid();
}

实际应用案例

案例一：Web API 中的实体到 DTO 映射

在 Web API 中，我们通常需要将数据库实体转换为 DTO 以返回给客户端：

// 实体类
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public int CategoryId { get; set; }
    public Category Category { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public bool IsDeleted { get; set; }
}

// DTO 类
public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public string CategoryName { get; set; }
}

// 映射配置
public class ProductMappingProfile : Profile
{
    public ProductMappingProfile()
    {
        CreateMap<Product, ProductDto>()
            .ForMember(dest => dest.CategoryName, 
                      opt => opt.MapFrom(src => src.Category.Name));
    }
}

// 在控制器中使用
[HttpGet]
public ActionResult<IEnumerable<ProductDto>> GetProducts()
{
    var products = _repository.GetActiveProducts();
    return Ok(_mapper.Map<IEnumerable<ProductDto>>(products));
}

案例二：表单提交到领域模型的映射

当处理用户提交的表单数据时，我们需要将视图模型映射到领域模型：

// 视图模型
public class UserRegistrationViewModel
{
    public string Username { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public string ConfirmPassword { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
}

// 领域模型
public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string PasswordHash { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 映射配置
public class UserMappingProfile : Profile
{
    public UserMappingProfile()
    {
        CreateMap<UserRegistrationViewModel, User>()
            .ForMember(dest => dest.PasswordHash, 
                      opt => opt.MapFrom(src => HashPassword(src.Password)))
            .ForMember(dest => dest.CreatedAt, 
                      opt => opt.MapFrom(src => DateTime.UtcNow))
            .ForMember(dest => dest.Id, opt => opt.Ignore());
    }
    
    private string HashPassword(string password)
    {
        // 实际应用中应使用安全的密码哈希算法
        return BCrypt.Net.BCrypt.HashPassword(password);
    }
}

// 在控制器中使用
[HttpPost]
public ActionResult Register(UserRegistrationViewModel model)
{
    if (!ModelState.IsValid)
        return BadRequest(ModelState);
        
    var user = _mapper.Map<User>(model);
    _userService.Create(user);
    
    return CreatedAtAction(nameof(GetUser), new { id = user.Id }, null);
}

常见问题与解决方案

问题一：映射配置无效

当 AssertConfigurationIsValid() 方法抛出异常时，通常是因为存在未配置的属性映射。解决方案：

  1. 确保所有需要映射的属性都已配置
  2. 对于不需要映射的属性，使用 Ignore() 方法明确忽略
  3. 使用 CreateMap<Source, Destination>().ForAllMembers(opt => opt.Condition((src, dest, srcMember) => srcMember != null)); 忽略所有空值

问题二：循环引用

当对象之间存在循环引用时，AutoMapper 可能会陷入无限循环。解决方案：

  1. 在映射配置中使用 MaxDepth(n) 限制递归深度
  2. 在循环引用的一端使用 Ignore() 方法
CreateMap<Parent, ParentDto>()
    .ForMember(dest => dest.Children, opt => opt.MapFrom(src => src.Children))
    .MaxDepth(2);

CreateMap<Child, ChildDto>()
    .ForMember(dest => dest.Parent, opt => opt.Ignore());

问题三：性能问题

对于大量对象的映射，性能可能成为问题。解决方案：

  1. 使用 ProjectTo<T>() 在数据库查询级别执行映射
  2. 编译映射配置
  3. 考虑使用对象池来重用 Mapper 实例

最佳实践

  1. 组织映射配置：将映射配置组织到单独的 Profile 类中，按领域或功能分组
  2. 验证映射配置：使用 AssertConfigurationIsValid() 方法验证映射配置
  3. 使用依赖注入：在 ASP.NET Core 应用中使用依赖注入来管理 AutoMapper
  4. 避免深层嵌套映射：对于复杂对象图，考虑分解为多个映射步骤
  5. 编写单元测试：为映射配置编写单元测试，确保映射行为符合预期
  6. 使用 ProjectTo：在 LINQ 查询中使用 ProjectTo<T>() 方法提高性能

结论

AutoMapper 是一个强大的对象映射工具，可以显著减少样板代码，提高开发效率。通过本文介绍的基本用法、高级特性和最佳实践，你应该能够在自己的 C# 项目中有效地使用 AutoMapper 进行对象映射。

记住，虽然 AutoMapper 可以自动处理大多数映射场景，但对于复杂的业务逻辑，有时手动映射或自定义解析器可能是更好的选择。选择合适的工具和方法，取决于你的具体需求和场景。

参考资源

深入C#对象映射：不依赖映射框架的实现策略
墨夶的博客
11-30 381
在C#开发中，对象映射是一个常见的需求，尤其是在处理数据传输对象（DTO）和数据库实体之间转换时。虽然有如AutoMapper这样的强大映射框架，但有时我们可能需要或想要不依赖于这些框架来实现对象映射。本文将探讨几种在C#中实现对象映射的方法，无需任何映射框架的辅助。
在 C# 中使用 AutoMapper 进行对象映射
Hellc007的博客
08-14 2028
C# 中使用 AutoMapper 进行对象映射。AutoMapper 是一个非常强大的工具，它可以减少手动编写映射代码的工作量
不错的东西： AutoMapper
webdev
10-29 143
详细信息可阅读原文：http://csharppulse.blogspot.in/2013/08/crud-operations-using-automapper-in-c_381.html 这东西可简化将模型转换为实体的代码，具体可看代码： 目前习惯写法的代码： public ActionResult Details(int? id) { var dbC...
C#对象映射器
qq_38697743的博客
04-13 1527
C#对象映射器 常规做法： 重载 public static implicit operator ClassB(ClassA v) { ClassBls = new ClassB(); ls.Id = v.Id; } 直接复值 使用Mapster方式 像AutoMapper和Mapster就是解决这种问题的，而我为什么选择Mapster，主要还是Mapster性能更好！ 基本映射之映射到新对象 public void BasicMappingNewObject(SourceObjectTest sourc
C# AutoMapper 了解一下
A15210311344的博客
04-18 317
什么是AutoMapper？ 简单来说就是将一个对象映射到另一个对象的代码。 摆脱了繁琐的赋值过程 （最常见也就是Model -——ViewModel） AutoMapper安装 我使用的是VS2015 可以在NuGet中直接输入AutoMapper 去下载 也可以使用控制台命令 PM> Install-Package AutoMapper 这...
C#使用AutoMapper6.2.2.0进行对象映射
android_dong12345的博客
04-19 354
先说说DTO DTO是个什么东东？ DTO（Data Transfer Object）就是数据传输对象，说白了就是一个对象，只不过里边全是数据而已。 为什么要用DTO? 1、DTO更注重数据，对领域对象进行合理封装，从而不会将领域对象的行为过分暴露给表现层 2、DTO是面向UI的需求而设计的，而领域模型是面向业务而设计的。因此DTO更适合于和表现层的交互，通过DTO我们实现了表...
C# AutoMapper 9.0.0入门与配置详解
本文主要介绍了C# AutoMapper 9.0.0的使用方法，这是一个强大的对象-对象映射库，用于简化不同对象模型之间的数据转换。本文通过两个关键部分来阐述如何有效地利用AutoMapper： 1. 入门示例： - 首先，作者定义了...
C#Map映射各个方式性能大比拼
01-11
在C#编程中，映射（Map）通常指的是对象之间的转换或复制过程，尤其是在需要创建一个新对象作为已有对象副本时。本篇文章将探讨几种不同的C#对象复制方法，并进行性能对比，帮助开发者选择最合适的策略。以下是所...
C#映射
最新发布
06-15
C# 中的映射实现多样，对象映射优先使用 AutoMapper 或 JSON 序列化以平衡性能和易用性；URL 映射依赖哈希算法。反射提供底层灵活性但需谨慎使用。实际开发中，结合需求选择合适方法，能显著提升代码质量和效率[^1]...
C# 类与实体间转换：详解属性定义与数据类型
在C#编程语言中，类和实体是构成面向对象程序设计的基本元素。理解类与实体之间的转换是实现数据模型与业务逻辑层之间交互的关键。本知识点将详细介绍C#中类、实体、以及它们之间转换的多种方法和策略。 ### C# 类...
C# AutoMapper 使用方法总结
12-17
本文基于 AutoMapper 9.0.0 AutoMapper 是一个对象-对象映射器，可以将一个对象映射到另一个对象。 官网地址：http://automapper.org/ 官方文档：https://docs.automapper.org/en/latest/ 1 入门例子 public class Foo { public int ID { get; set; } public string Name { get; set; } } public class FooDto { public int ID { get; set; } public string Name { g
C#.NET源码实现的进销存管理系统详解
4. **第三方库和框架：** 根据需求引入第三方库，例如NLog用于日志记录、AutoMapper用于对象映射等。 ### 系统维护与优化 系统开发完成后，还需要进行持续的维护和优化工作，以适应不断变化的业务需求和市场环境。...
C#-对象映射器（一）-AutoMapper映射帮助类
weixin_30146085的博客
08-08 574
一、AutoMapper简介1、什么是AutoMapper（官方文档地址：https://github.com/MapsterMapper/Mapster）  Mapster是一个高性能的用于对象映射的类库，同类型的产品还有AutoMapper。它提供了一系列的API和工具，以下为几个重要的类和接口： IMapping接...
C# 高性能对象映射（表达式树实现）
weixin_68436326的博客
07-08 568
来源：costyuancnblogs.com/castyuan/p/9324088.html开源对象映射类库映射分析1.AutoMapper实现原理：主要通过表达式树Api 实现对象映射优点： .net功能最全的对象映射类库。缺点：当出现复杂类型和嵌套类型时性能直线下降，甚至不如序列化快2.TinyMapper实现原理：主要通过Emit 实现对象映射优点：速度非常快。在处理复杂类型和嵌套类...
C# 高性能对象映射(表达式树实现)
weixin_30340775的博客
07-18 278
前言 上篇简单实现了对象映射,针对数组，集合，嵌套类并没有给出实现，这一篇继续完善细节。 开源对象映射类库映射分析 1.AutoMapper 实现原理：主要通过表达式树Api 实现对象映射 优点： .net功能最全的对象映射类库。 缺点：当出现复杂类型和嵌套类型时性能直线下降，甚至不如序列化快 2.TinyMapper 实现原...
C# AutoMapper
标准都是留给不爱的人，爱的本质是自由意志的沉沦
07-14 1190
} }} } }} } }} } }在上面的示例中，我们创建了一个类，并在其中定义了到的映射规则。} } }} } }} } }} } }在上面的示例中，我们使用了方法来为所有成员应用相同的映射策略。方法使用了反射来动态获取对象的属性值。
C# Mapster 对象映射器学习
Sun的专栏
06-17 5058
使用 Mapster 实现 User 到 UserDto 的映射 简单使用 Mapster 配置 (TypeAdapterConfig) 可以直接使用 Mapster 内置的全局静态配置 ，也可以实例化一个配置 推荐使用实例化的方式，对 TypeAdapterConfig 进行映射配置。直接在 TypeAdapterConfig 配置对象的映射关系 字段带有前后缀，可以使用 对目标字段名称进行替换，使得它和源字段名称相同。 还有替换源字段的方法 方式二 使用...
8分钟学会使用AutoMapper
qq_39110534的博客
11-22 326
一.什么是AutoMapper与为什么用它。 它是一种对象与对象之间的映射器，让AutoMapper有意思的就是在于它提供了一些将类型A映射到类型B这种无聊的实例，只要B遵循AutoMapper已经建立的惯例，那么大多数情况下就可以进行相互映射了。 二.如何使用？ 直接nuget install-package automapper 简单到不能再简单了。 三.入门 定义了连个简...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天天进步2015

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值