Utilisation d'AutoMapper pour déflater un DTO

Question

J'ai essayé d'utiliser AutoMapper pour gagner du temps en passant de mes DTO à mes objets de domaine, mais j'ai du mal à configurer la carte pour qu'elle fonctionne, et je commence à me demander si AutoMapper n'est pas le mauvais outil pour ce travail.

Considérons cet exemple d'objets de domaine (une entité et une valeur) :

public class Person
{
    public string Name { get; set; }
    public StreetAddress Address { get; set; }
}

public class StreetAddress
{
    public string Address { get; set; }
    public string City { get; set; }
    public string State { get; set; }
}

Mon DTO (d'un objet Linq à SQL) ressemble à peu près à ceci :

public class PersonDTO
{
    public string Name { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
    public string State { get; set; }
}

J'aimerais pouvoir le faire dans mon référentiel :

return Mapper.Map<PersonDTO, Person>(result);

J'ai essayé de configurer l'AutoMapper de toutes les manières possibles, mais je continue à obtenir le message générique suivant Configuration de carte de type manquante ou mappage non pris en charge sans aucun détail pour me dire où j'échoue.

J'ai essayé un certain nombre de configurations différentes, mais en voici quelques-unes :

Mapper.CreateMap<PersonDTO, Person>()
    .ForMember(dest => dest.Address, opt => opt.MapFrom(Mapper.Map<Person, Domain.StreetAddress>));

et

Mapper.CreateMap<Person, Domain.Person>()
    .ForMember(dest => dest.Address.Address1, opt => opt.MapFrom(src => src.Address))
    .ForMember(dest => dest.Address.City, opt => opt.MapFrom(src => src.City))
    .ForMember(dest => dest.Address.State, opt => opt.MapFrom(src => src.State));

J'ai lu que aplatissant d'objets avec AutoMapper est facile, mais dégonflement ce n'est pas facile... ni même possible. Quelqu'un peut-il me dire si j'essaie de faire l'impossible et, dans le cas contraire, ce que je fais de mal ?

Notez que mes objets réels sont un peu plus compliqués, il est donc possible que j'omette des informations qui sont la clé de l'erreur... si ce que je fais semble correct, je peux fournir plus d'informations ou commencer à simplifier mes objets pour les tester.

Answer 1

Cela semble également fonctionner pour moi :

Mapper.CreateMap<PersonDto, Address>();
Mapper.CreateMap<PersonDto, Person>()
        .ForMember(dest => dest.Address, opt => opt.MapFrom( src => src )));

En gros, il faut créer un mappage de la dto vers les deux objets, puis l'utiliser comme source pour l'objet enfant.

Answer 2

Je ne peux pas poster de commentaire, alors je poste une réponse. Je suppose qu'il y a eu des changements dans l'implémentation de l'AutoMapper, alors la réponse est la suivante https://stackoverflow.com/a/5154321/2164198 proposé par HansoS n'est plus compilable. Bien qu'il existe une autre méthode qui peut être utilisée dans de tels scénarios, à savoir - ResolveUsing :

Mapper.CreateMap<Person, Domain.Person>()
    .ForMember(dest => dest.Address, opt => opt.ResolveUsing( src => { return new Address() {Address1 = src.Address, City = src.City, State = src.State }; }))

Answer 3

En plus de la réponse de Sydney et selon le commentaire de Trevor de Koekkoek, la cartographie bidirectionnelle est possible de la manière suivante

public class Person
{
    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 State { get; set; }
}

public class PersonViewModel
{
    public string Name { get; set; }
    public string AddressStreet { get; set; }
    public string AddressCity { get; set; }
    public string AddressState { get; set; }
}

Mappages de l'Automapper

Mapper.Initialize(cfg => cfg.RecognizePrefixes("Address"));
Mapper.CreateMap<Person, PersonViewModel>();
Mapper.CreateMap<PersonViewModel, Address>();
Mapper.CreateMap<PersonViewModel, Person>()
    .ForMember(dest => dest.Address, opt => opt.MapFrom( src => src )));

Si vous mettez en œuvre Nom du site vous pouvez vous débarrasser de la chaîne magique préfixe

Mapper.Initialize(cfg => cfg.RecognizePrefixes(Nameof<Person>.Property(x => x.Address)));

EDIT : En C# 6

Mapper.Initialize(cfg => cfg.RecognizePrefixes(nameof(Person.Address)));

Answer 4

Utiliser https://github.com/omuleanu/ValueInjecter c'est le cas aplatissant y dégonflement et tout ce dont vous avez besoin. asp.net mvc sample application in the download où toutes les fonctionnalités sont démontrées (également les tests unitaires)

Answer 5

Cela peut être tardif mais vous pouvez résoudre ce problème en utilisant des expressions lambda pour créer l'objet comme ceci :

Mapper.CreateMap<Person, Domain.Person>()
        .ForMember(dest => dest.Address, opt => opt.MapFrom( src => { return new Address() {Address1 = src.Address, City = src.City, State = src.State }; }))