ASP.NET de Base avec les objectifs EF de Base - DTO mappage de la Collection

Je suis en train d'utiliser (POST/PUT) un DTO objet avec une collection d'objets enfants à partir de JavaScript à un ASP.NET de Base (API Web) avec une EF Base de contexte de que mon la source de données.

Le principal DTO classe est quelque chose comme ceci (simplifié de cours):

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

Ce que je ne sais pas vraiment est de savoir comment la carte au Client, entité de la classe d'une manière qui ne comprennent pas beaucoup de code juste pour trouver des Personnes a été ajouté/modifié/supprimé etc.

J'ai joué un peu avec les AutoMapper mais il ne semble pas vraiment à jouer gentil avec les objectifs EF de Base dans ce scénario (complexe de la structure de l'objet) et les collections.

Après googler pour quelques conseils autour de cela, je n'ai pas trouvé de bonnes ressources autour de ce qu'est une bonne approche serait. Mes questions c'est en gros: dois-je la refonte du JS-client de ne pas utiliser "complexe" Dto ou est-ce quelque chose qui "devrait" être manipulé par une couche de mappage entre mes Otd et modèle d'Entité ou de toute autre solution de bon que je ne suis pas au courant?

J'ai été en mesure de résoudre à la fois les AutoMapper et et par la main de mapping entre les objets, mais aucune des solutions qui se sent bien et rapidement devenir assez complexe avec beaucoup de code réutilisable.

EDIT:

L'article suivant décrit à quoi je fais référence concernant AutoMapper et EF de Base. Son pas de code compliqué, mais je veux juste savoir si c'est la "meilleure" façon de gérer cela.

(Code de l'article est modifié pour s'adapter à l'exemple de code ci-dessus)

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;

Code ci-dessus écrit comme une extension générique de la méthode.

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>);

Edit:

Une chose que je veux vraiment, c'est delcare la AutoMapper de configuration en un seul lieu (le Profil) de ne pas avoir à utiliser le MapCollection() extension à chaque fois que j'utilise le mappeur (ou toute autre solution qui nécessite de compliquer le code de mappage).

J'ai donc créé une méthode d'extension comme ce

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);
    }
}

Puis, quand je créer les mappages je nous comme ceci:

    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));
            });
        });

Qui me permettent de l'utiliser comme cela au moment de la cartographie:

_mapper.Map(customerDto, customer);

Et le résolveur prend soin de la cartographie.

OriginalL'auteur jmw | 2016-09-12