C# AutoMapper对象映射详解

最新推荐文章于 2025-06-13 10:03:09 发布
原创 最新推荐文章于 2025-06-13 10:03:09 发布 · 1k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c# #开发语言

引言

在现代软件开发中，特别是采用分层架构的应用程序，我们经常需要在不同的对象类型之间进行转换。例如，从数据库实体（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# 中使用 AutoMapper 进行对象映射
Hellc007的博客
08-14 2032
C# 中使用 AutoMapper 进行对象映射。AutoMapper 是一个非常强大的工具，它可以减少手动编写映射代码的工作量
C#Map映射各个方式性能大比拼
01-11
在C#编程中，映射（Map）通常指的是对象之间的转换或复制过程，尤其是在需要创建一个新对象作为已有对象副本时。本篇文章将探讨几种不同的C#对象复制方法，并进行性能对比，帮助开发者选择最合适的策略。以下是所...
C#中的映射
de14141983的专栏
01-11 808
C#编译后的文件主要由IL代码和元数据组成，元数据为.NET组件提供了丰富的自描述特性，它使得我们可以在代码运行时获知组件中的类型等重要的信息。C#中这是通过一种称作映射（Reflection）的机制来完成的。 动态类型查询 首先创建一个简单的类型： namespace ReflectionClass { public class MyClass { ...
从入门到精通：C# 中 AutoMapper 的深度解析与实战应用
程序人生，算法世界
06-13 831
本文全面介绍C#开发中AutoMapper对象映射工具的应用。作为简化不同对象类型属性映射的开源库，AutoMapper能高效处理数据库实体与DTO之间的转换，解决手动映射繁琐易错的问题。文章从基础安装配置讲起，涵盖集合映射、反向映射、条件映射等进阶用法，并深入解析自定义值解析器、继承映射等高级技巧。同时介绍了AutoMapper在ASP.NET Core中的集成方式及性能优化建议，包括避免重复实例化和预编译映射等实践。通过合理运用AutoMapper，开发者能显著提升C#项目开发效率，减少手动映射带来的维
C#对象映射器
qq_38697743的博客
04-13 1528
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映射帮助类
weixin_30146085的博客
08-08 576
一、AutoMapper简介1、什么是AutoMapper（官方文档地址：https://github.com/MapsterMapper/Mapster）  Mapster是一个高性能的用于对象映射的类库，同类型的产品还有AutoMapper。它提供了一系列的API和工具，以下为几个重要的类和接口： IMapping接...
不错的东西： 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# AutoMapper
标准都是留给不爱的人，爱的本质是自由意志的沉沦
07-14 1192
} }} } }} } }} } }在上面的示例中，我们创建了一个类，并在其中定义了到的映射规则。} } }} } }} } }} } }在上面的示例中，我们使用了方法来为所有成员应用相同的映射策略。方法使用了反射来动态获取对象的属性值。
C# AutoMapper 9.0.0入门与配置详解
本文主要介绍了C# AutoMapper 9.0.0的使用方法，这是一个强大的对象-对象映射库，用于简化不同对象模型之间的数据转换。本文通过两个关键部分来阐述如何有效地利用AutoMapper： 1. 入门示例： - 首先，作者定义了...
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# 高性能对象映射（表达式树实现）
weixin_68436326的博客
07-08 569
来源：costyuancnblogs.com/castyuan/p/9324088.html开源对象映射类库映射分析1.AutoMapper实现原理：主要通过表达式树Api 实现对象映射优点： .net功能最全的对象映射类库。缺点：当出现复杂类型和嵌套类型时性能直线下降，甚至不如序列化快2.TinyMapper实现原理：主要通过Emit 实现对象映射优点：速度非常快。在处理复杂类型和嵌套类...
【C#关于AutoMapper】
weixin_43605345的博客
11-21 1870
一次配置：只需在一个地方定义对象的转换规则。直接调用：用 mapper.Map 方法即可完成所有对象的转换。节省代码：不用每次都写重复的赋值逻辑。集中管理：所有转换规则都在一个地方，修改时不需要到处找。清晰且易维护：映射逻辑独立、集中，业务代码更简洁。
C# AutoMapper 了解一下
A15210311344的博客
04-18 318
什么是AutoMapper？ 简单来说就是将一个对象映射到另一个对象的代码。 摆脱了繁琐的赋值过程 （最常见也就是Model -——ViewModel） AutoMapper安装 我使用的是VS2015 可以在NuGet中直接输入AutoMapper 去下载 也可以使用控制台命令 PM> Install-Package AutoMapper 这...
C#:关于AutoMapper（刚接触 记录一下）
qq_33472553的博客
12-16 586
前言： 背景： 最初用到这个东西，是为了更好的对实体类进行安全性的装饰，新建一个类，把这个实体类需要的字段名丢进去。 比如person类，有姓名性别爱好，我只要姓名和性别，就新建一个NewPerson类。 但是你得到了这个NewPerson类的对象后，你需要换成原来的Person对象，然后丢到数据库里去。 理由： 为什么需要当然了，如果字段名足够少，你可以用 . 点，一个一个点，但是字...
【C#】使用AutoMapper-看这篇就够了
热门推荐
catshitone的专栏
11-20 4万+
1.基本配置 Profile配置 public class OrganizationProfile : Profile { public OrganizationProfile() { CreateMap<Foo, FooDto>(); } } 使用： var configuration = new MapperConfiguration(cfg => { //cfg.CreateMap<Foo, Bar>(); cfg.AddProfile<
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

天天进步2015

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

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

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

打赏作者

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

抵扣说明：

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

余额充值