Question

我正在尝试使用（POST / PUT）DTO对象，其中包含从JavaScript到ASP.NET Core（Web API）的子对象集合，其中EF Core上下文作为我的数据源。

主要的DTO类是这样的（当然简化）：

public class CustomerDto {
    public int Id { get;set }
    ...
    public IList<PersonDto> SomePersons { get; set; }
    ...
}

我真正不知道的是如何以不包含大量代码的方式将其映射到Customer实体类，只是为了找出添加/更新/删除了哪些人员等。

我使用AutoMapper玩了一下，但在这种情况下（复杂的对象结构）和集合，它似乎与EF Core不太匹配。

在谷歌搜索一些关于这方面的建议后，我没有找到任何好的资源来解决一个好的方法。我的问题基本上是：我应该重新设计JS客户端以不使用“复杂”DTO，还是应该由我的DTO和实体模型之间的映射层处理，或者是否有任何其他好的解决方案我不是知道吗？

我已经能够通过AutoMapper和手动映射对象来解决它，但是没有一个解决方案感觉正确，并且很快就会变得非常复杂，需要很多样板代码。

修改

以下文章描述了我所指的AutoMapper和EF Core。它不是复杂的代码，但我只是想知道它是否是管理它的“最佳”方式。

（编辑文章中的代码以符合上面的代码示例）

http://cpratt.co/using-automapper-mapping-instances/

var updatedPersons = new List<Person>();
foreach (var personDto in customerDto.SomePersons)
{
    var existingPerson = customer.SomePersons.SingleOrDefault(m => m.Id == pet.Id);
    // No existing person with this id, so add a new one
    if (existingPerson == null)
    {
        updatedPersons.Add(AutoMapper.Mapper.Map<Person>(personDto));
    }
    // Existing person found, so map to existing instance
    else
    {
        AutoMapper.Mapper.Map(personDto, existingPerson);
        updatedPersons.Add(existingPerson);
    }
}
// Set SomePersons to updated list (any removed items drop out naturally)
customer.SomePersons = updatedPersons;

以上代码编写为通用扩展方法。

public static void MapCollection<TSourceType, TTargetType>(this IMapper mapper, Func<ICollection<TSourceType>> getSourceCollection, Func<TSourceType, TTargetType> getFromTargetCollection, Action<List<TTargetType>> setTargetCollection)
    {
        var updatedTargetObjects = new List<TTargetType>();
        foreach (var sourceObject in getSourceCollection())
        {
            TTargetType existingTargetObject = getFromTargetCollection(sourceObject);
            updatedTargetObjects.Add(existingTargetObject == null
                ? mapper.Map<TTargetType>(sourceObject)
                : mapper.Map(sourceObject, existingTargetObject));
        }
        setTargetCollection(updatedTargetObjects);
    }

.....

        _mapper.MapCollection(
            () => customerDto.SomePersons,
            dto => customer.SomePersons.SingleOrDefault(e => e.Id == dto.Id),
            targetCollection => customer.SomePersons = targetCollection as IList<Person>);

修改

我真正想要的一件事是将AutoMapper配置delcare在一个地方（Profile），每次我使用mapper（或任何其他需要复制映射代码的解决方案）时都不必使用MapCollection（）扩展。

所以我创建了一个像这样的扩展方法

public static class AutoMapperExtensions
{
    public static ICollection<TTargetType> ResolveCollection<TSourceType, TTargetType>(this IMapper mapper,
        ICollection<TSourceType> sourceCollection,
        ICollection<TTargetType> targetCollection,
        Func<ICollection<TTargetType>, TSourceType, TTargetType> getMappingTargetFromTargetCollectionOrNull)
    {
        var existing = targetCollection.ToList();
        targetCollection.Clear();
        return ResolveCollection(mapper, sourceCollection, s => getMappingTargetFromTargetCollectionOrNull(existing, s), t => t);
    }

    private static ICollection<TTargetType> ResolveCollection<TSourceType, TTargetType>(
        IMapper mapper,
        ICollection<TSourceType> sourceCollection,
        Func<TSourceType, TTargetType> getMappingTargetFromTargetCollectionOrNull,
        Func<IList<TTargetType>, ICollection<TTargetType>> updateTargetCollection)
    {
        var updatedTargetObjects = new List<TTargetType>();
        foreach (var sourceObject in sourceCollection ?? Enumerable.Empty<TSourceType>())
        {
            TTargetType existingTargetObject = getMappingTargetFromTargetCollectionOrNull(sourceObject);
            updatedTargetObjects.Add(existingTargetObject == null
                ? mapper.Map<TTargetType>(sourceObject)
                : mapper.Map(sourceObject, existingTargetObject));
        }
        return updateTargetCollection(updatedTargetObjects);
    }
}

然后，当我创建映射时，我就像这样：

    CreateMap<CustomerDto, Customer>()
        .ForMember(m => m.SomePersons, o =>
        {
            o.ResolveUsing((source, target, member, ctx) =>
            {
                return ctx.Mapper.ResolveCollection(
                    source.SomePersons,
                    target.SomePersons,
                    (targetCollection, sourceObject) => targetCollection.SingleOrDefault(t => t.Id == sourceObject.Id));
            });
        });

允许我在映射时使用它：

_mapper.Map(customerDto, customer);

解析器负责映射。

Answer 1

AutoMapper是最佳解决方案。

你可以很容易地做到这一点：

    Mapper.CreateMap<Customer, CustomerDto>();
    Mapper.CreateMap<CustomerDto, Customer>();

    Mapper.CreateMap<Person, PersonDto>();
    Mapper.CreateMap<PersonDto, Person>();

注意：因为AutoMapper会自动将List<Person>映射到List<PersonDto>，因为他们有same name，并且已有Person至PersonDto。

如果你需要知道如何将它注入ASP.net核心，你必须看到这篇文章：Integrating AutoMapper with ASP.NET Core DI

DTO与实体之间的自动映射

Mapping using attributes and extension methods

Answer 2

很长一段时间以来，我一直在努力解决同样的问题。在深入研究了很多文章后，我提出了自己的实现，并与您分享。

首先，我创建了一个自定义IMemberValueResolver。

using System;
using System.Collections.Generic;
using System.Linq;

namespace AutoMapper
{
    public class CollectionValueResolver<TDto, TItemDto, TModel, TItemModel> : IMemberValueResolver<TDto, TModel, IEnumerable<TItemDto>, IEnumerable<TItemModel>>
        where TDto : class
        where TModel : class
    {
        private readonly Func<TItemDto, TItemModel, bool> _keyMatch;
        private readonly Func<TItemDto, bool> _saveOnlyIf;

        public CollectionValueResolver(Func<TItemDto, TItemModel, bool> keyMatch, Func<TItemDto, bool> saveOnlyIf = null)
        {
            _keyMatch = keyMatch;
            _saveOnlyIf = saveOnlyIf;
        }

        public IEnumerable<TItemModel> Resolve(TDto sourceDto, TModel destinationModel, IEnumerable<TItemDto> sourceDtos, IEnumerable<TItemModel> destinationModels, ResolutionContext context)
        {
            var mapper = context.Mapper;

            var models = new List<TItemModel>();
            foreach (var dto in sourceDtos)
            {
                if (_saveOnlyIf == null || _saveOnlyIf(dto))
                {
                    var existingModel = destinationModels.SingleOrDefault(model => _keyMatch(dto, model));
                    if (EqualityComparer<TItemModel>.Default.Equals(existingModel, default(TItemModel)))
                    {
                        models.Add(mapper.Map<TItemModel>(dto));
                    }
                    else
                    {
                        mapper.Map(dto, existingModel);
                        models.Add(existingModel);
                    }
                }
            }

            return models;
        }
    }
}

然后我配置AutoMapper并添加我的特定映射：

cfg.CreateMap<TDto, TModel>()
    .ForMember(dst => dst.DestinationCollection, opts =>
        opts.ResolveUsing(new CollectionValueResolver<TDto, TItemDto, TModel, TItemModel>((src, dst) => src.Id == dst.SomeOtherId, src => !string.IsNullOrEmpty(src.ThisValueShouldntBeEmpty)), src => src.SourceCollection));

由于构造函数中传递的keyMatch函数，此实现允许我完全自定义对象匹配逻辑。如果由于某种原因需要验证传递的对象（如果它们适合映射），也可以传递一个额外的saveOnlyIf函数（在我的情况下，有些对象不应该映射并添加到集合中，如果它们没有'通过额外的验证）。

然后，例如在控制器中，如果要更新断开连接的图形，则应执行以下操作：

var model = await Service.GetAsync(dto.Id); // obtain existing object from db
Mapper.Map(dto, model);
await Service.UpdateAsync(model);

这对我有用。如果这个实现比你编辑的帖子中提出的这个问题的作者更适合你，那取决于你：）

Answer 3

首先，我建议使用JsonPatchDocument进行更新：

    [HttpPatch("{id}")]
    public IActionResult Patch(int id, [FromBody] JsonPatchDocument<CustomerDTO> patchDocument)
    {
        var customer = context.EntityWithRelationships.SingleOrDefault(e => e.Id == id);
        var dto = mapper.Map<CustomerDTO>(customer);
        patchDocument.ApplyTo(dto);
        var updated = mapper.Map(dto, customer);
        context.Entry(entity).CurrentValues.SetValues(updated);
        context.SaveChanges();
        return NoContent();
    }

然后使用AutoMapper.Collections.EFCore进行处理。这就是我在Startup.cs中使用扩展方法配置AutoMapper的方式，因此我可以在没有整个配置代码的情况下调用services.AddAutoMapper()：

    public static IServiceCollection AddAutoMapper(this IServiceCollection services)
    {
        var config = new MapperConfiguration(cfg =>
        {
            cfg.AddCollectionMappers();
            cfg.UseEntityFrameworkCoreModel<MyContext>(services);
            cfg.AddProfile(new YourProfile()); // <- you can do this however you like
        });
        IMapper mapper = config.CreateMapper();
        return services.AddSingleton(mapper);
    }

YourProfile应该是这样的：

    public YourProfile()
    {
        CreateMap<Person, PersonDTO>(MemberList.Destination)
            .EqualityComparison((p, dto) => p.Id == dto.Id)
            .ReverseMap();

        CreateMap<Customer, CustomerDTO>(MemberList.Destination)
            .ReverseMap();
    }

我有一个类似的对象图，这对我来说很好。

编辑我使用LazyLoading，如果不需要的话，则必须显式加载navigationProperties / Collections。

ASP.NET核心与EF核心 - DTO集合映射

修改

修改

3 个答案: