概述

dotnet automapper.extensions.microsoft.dependencyinjection是一款用于.NET Core平台的Object-to-Object映射组件，为程序员提供了可扩展、灵活的数据映射方式。同时，该组件也可以轻松集成依赖注入，使其在.NET Core应用程序中使用更加便捷。

特性

• 支持对象之间自动和显式的属性映射
• 支持在对象之间进行多个源对象和多个目标对象之间的映射
• 支持使用Lambda表达式映射对象之间的属性
• 支持自定义类型转换和自定义值转换器
• 支持在.NET Core应用程序中进行依赖注入

安装

你可以使用NuGet包管理器来安装dotnet automapper.extensions.microsoft.dependencyinjection组件。

Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

用法

初步使用

在我们的.NET Core应用程序中，我们需要在Startup.cs文件中进行依赖注入。

在ConfigureServices 方法中添加以下代码：

public void ConfigureServices(IServiceCollection services)
{
    services.AddAutoMapper(typeof(Startup));
}

然后，我们需要使用IMapper接口来实现对象的映射。在您的Controller或服务中注入IMapper依赖项。以下是一个示例：

public class HomeController : Controller { 
     private readonly IMapper _mapper; 
  
     public HomeController(IMapper mapper) { 
         _mapper = mapper; 
     } 
  
     public IActionResult Index() { 
         // Create a source entity 
         var customer = new Customer { 
             FirstName = "John", 
             LastName = "Doe", 
             Age = 35, 
             Address = new Address { 
                 Street = "35 Little Bourke St", 
                 City = "Melbourne", 
                 Province = "VIC" 
             } 
         }; 
  
         // Map the source entity to a view model 
         var customerViewModel = _mapper.Map<CustomerViewModel>(customer); 
  
          return View(customerViewModel); 
     } 
}

在此示例中，我们创建了一个名为“customer”的源实体，并使用IMapper接口将其映射到一个名为“customerViewModel”的目标视图模型。

自动映射

AutoMapper可以使用它的配置系统自动映射对象之间的属性。以下是一个简单的示例：

Mapper.Initialize(cfg => cfg.CreateMap<Order, OrderDTO>()); 
var order = new Order { Customer = new Customer { Name = "John Doe" } }; 
var orderDto = Mapper.Map<OrderDTO>(order); 
Console.WriteLine($"{orderDto.CustomerName}"); // John Doe 

在此示例中，我们使用Mapper.Initialize()方法创建了一个映射，该映射将Order对象映射到OrderDTO对象。此后，我们可以使用Mapper.Map()方法将Order对象转换为OrderDTO对象。

手动映射

除了自动映射之外，AutoMapper还可以使用手动映射来处理一些复杂的映射。以下是一个示例，展示了如何通过手动映射来处理嵌套属性：

var config = new MapperConfiguration(cfg => 
{ 
    cfg.CreateMap<Order, OrderDto>() 
        .ForMember(destination => destination.CustomerName, 
        options => options.MapFrom(source => $"{source.Customer.FirstName} {source.Customer.LastName}")) 
        .ForAllOtherMembers(options => options.Ignore()); 
}); 

var mapper = config.CreateMapper(); 

var order = new Order { Customer = new Customer { FirstName = "John", LastName = "Doe" } }; 
var orderDto = mapper.Map<OrderDto>(order); 

Console.WriteLine($"{orderDto.CustomerName}"); // John Doe 

在此示例中，我们明确将Order对象的Customer属性映射到OrderDTO对象的CustomerName属性。

自定义类型转换

有时，我们需要自定义类型转换以映射两个不兼容的类型之间的数据。以下是一个自定义类型转换的示例，用于将一个Person对象映射到一个Employee对象：

class Person { 
    public string FullName { get; set; } 
    public DateTime BirthDate { get; set; } 
} 

class Employee { 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public DateTime HireDate { get; set; } 
} 

class PersonToEmployeeTypeConverter : ITypeConverter<Person, Employee> { 
    public Employee Convert(Person source, Employee destination, ResolutionContext context) { 
        var fullName = source.FullName.Split(' '); 
        destination.FirstName = fullName[0]; 
        destination.LastName = fullName[1]; 
        destination.HireDate = DateTime.Now; 

        return destination; 
    } 
} 

var config = new MapperConfiguration(cfg => 
{ 
    cfg.CreateMap<Person, Employee>().ConvertUsing<PersonToEmployeeTypeConverter>(); 
}); 

var mapper = config.CreateMapper(); 

var person = new Person { FullName = "John Doe", BirthDate = new DateTime(1980, 1, 1) }; 
var employee = mapper.Map<Employee>(person); 

Console.WriteLine($"{employee.FirstName} {employee.LastName} ({employee.HireDate.ToShortDateString()})"); // John Doe (4/6/2020) 

在此示例中，我们创建了一个名为PersonToEmployeeTypeConverter的类型转换器，用于将Person对象映射到Employee对象。我们将其添加到映射配置中使用ConvertUsing方法。

自定义值转换

有时候，我们需要对源对象的属性进行操作以生成目标对象的属性。例如，我们可以将一个名为Customer的对象映射到一个名为CustomerViewModel的对象，我们可以将Customer对象的Address属性映射到CustomerViewModel对象的AddressViewModel属性。在此过程中，我们可能需要对Address属性的值进行转换。以下是一个示例：

class AddressValueResolver : IValueResolver<Customer, CustomerViewModel, AddressViewModel> { 
        public AddressViewModel Resolve(Customer source, 
                                         CustomerViewModel destination, 
                                         AddressViewModel destMember, 
                                         ResolutionContext context) { 
  
            var sourceAddress = source.Address; 
            var destinationAddress = new AddressViewModel { FullAddress = $"{sourceAddress.Street}, {sourceAddress.City}, {sourceAddress.Province}" }; 
  
            return destinationAddress; 
        } 
    } 

    var config = new MapperConfiguration(cfg => 
    { 
        cfg.CreateMap<Customer, CustomerViewModel>() 
            .ForMember(destination => destination.AddressViewModel, 
            options => options.MapFrom<AddressValueResolver>()); 
    }); 

    var mapper = config.CreateMapper(); 
    var customer = new Customer { 
        FirstName = "John", 
        LastName = "Doe", 
        Age = 35, 
        Address = new Address { 
            Street = "35 Little Bourke St", 
            City = "Melbourne", 
            Province = "VIC" 
        } 
    }; 
  
    var customerViewModel = mapper.Map<CustomerViewModel>(customer); 
    Console.WriteLine($"{customerViewModel.AddressViewModel.FullAddress}"); // 35 Little Bourke St, Melbourne, VIC 

在此示例中，我们创建了一个名为AddressValueResolver的值解析器，用于将Customer对象的Address属性映射到CustomerViewModel对象的AddressViewModel属性。我们将其添加到映射配置中使用MapFrom方法。

结论

dotnet automapper.extensions.microsoft.dependencyinjection是一款功能强大的映射组件，可以轻松地在.NET Core应用程序中实现依赖注入。使用自动映射和手动映射，以及使用自定义类型转换器和自定义值转换来轻松处理不兼容的对象类型之间的转换。