如何使用AutoMapper反向映射到现有的父对象? [英] How to reverse map to an existing parent object using AutoMapper?

问题描述

请考虑以下课程:

public class Customer
{
    public Guid Id { get; set; }
    public List<Address> Addresses { get; set; }
    public List<Order> Orders { get; set; }
}

public class Address
{
    public Guid Id { get; set; }
    public Customer Customer { get; set; }    // parent
    // ...
}

public class Order
{
    public Guid Id { get; set; }
    public Customer Customer { get; set; }    // parent
    public Address Address { get; set; }
    // ...
}

以及数据传输对象(DTO):

And the data transfer objects (DTOs):

public class CustomerDto
{
    public Guid Id { get; set; }
    public AddressDto[] Addresses { get; set; }
    public OrderDto[] Orders { get; set; }
}

public class AddressDto
{
    public Guid Id { get; set; }
    public Guid CustomerId { get; set; }
    // ...
}

public class OrderDto
{
    public Guid Id { get; set; }
    public Guid CustomerId { get; set; }
    public Guid AddressId { get; set; }
}

从Customer映射到CustomerDto很容易.但是，我在从CustomerDto到Customer的反向映射时遇到了麻烦.

Mapping (and flattening) from Customer to CustomerDto is easy. However, I'm having trouble reverse mapping from CustomerDto to Customer.

AutoMapper无法确定Address或Order中的Customer属性.它也无法找出Order中的Address属性.

AutoMapper is not able to figure out the Customer property in Address or Order. It also can't figure out the Address property in Order.

我可以先使用Ignore配置方法忽略"这些属性，然后使用AfterMap手动查找对象并适当地分配它们，以使其工作.

I can make it work by first "ignoring" these properties by using the Ignore configuration method, and then using AfterMap to manually find the objects and assign them appropriately.

AutoMapper是否可以自动执行此操作?

Is there a way for AutoMapper to do this automatically?

推荐答案

我认为您正在寻找的是.ReverseMap()-

I think what you are looking for is .ReverseMap() - http://docs.automapper.org/en/stable/Reverse-Mapping-and-Unflattening.html

因此，给出了以下映射:

So given the following mappings:

        var mapper = new MapperConfiguration(expression =>
        {
            expression.CreateMap<Customer, CustomerDto>()
                .ForMember(dto => dto.Id, obj => obj.MapFrom(customer => customer.Id))
                .ReverseMap();
            expression.CreateMap<Address, AddressDto>()
                .ForMember(dto => dto.Id, obj => obj.MapFrom(address => address.Id))
                .ForMember(dto => dto.CustomerId, obj => obj.MapFrom(address => address.Customer.Id))
                .ReverseMap();
            expression.CreateMap<Order, OrderDto>()
                .ForMember(dto => dto.Id, obj => obj.MapFrom(order => order.Id))
                .ForMember(dto => dto.AddressId, obj => obj.MapFrom(order => order.Address.Id))
                .ForMember(dto => dto.CustomerId, obj => obj.MapFrom(order => order.Customer.Id))
                .ReverseMap();
        }).CreateMapper();

和对象:

        var customerTest = new Customer
        {
            Id = Guid.NewGuid(),
            Addresses = new List<Address>
            {
                new Address
                {
                    Id = Guid.NewGuid(),
                    Customer = new Customer{ Id = Guid.NewGuid() }
                }
            },
            Orders = new List<Order>
            {
                new Order
                {
                    Id = Guid.NewGuid(),
                    Customer = new Customer{ Id = Guid.NewGuid() },
                    Address = new Address{ Id = Guid.NewGuid() }
                }
            }
        };

您可以执行以下操作:

        var resultDto = mapper.Map<CustomerDto>(customerTest);
        var resultModel = mapper.Map<Customer>(resultDto);

这篇关于如何使用AutoMapper反向映射到现有的父对象?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！