AutoMapper convertir à partir de plusieurs sources

Disons que j'ai deux classes de modèles:

public class People {
   public string FirstName {get;set;}
   public string LastName {get;set;}
}

Ont aussi une classe de Téléphone:

public class Phone {
   public string Number {get;set;}
}

Et je tiens à les convertir à un PeoplePhoneDto comme ceci:

public class PeoplePhoneDto {
    public string FirstName {get;set;}
    public string LastName {get;set;}
    public string PhoneNumber {get;set;}
}

Disons que dans mon contrôleur, j'ai:

var people = repository.GetPeople(1);
var phone = repository.GetPhone(4);

//normally, without automapper I would made
return new PeoplePhoneDto(people, phone) ;

Je n'arrive pas à trouver un exemple de ce scénario. Est-ce possible ?

Remarque: l'Exemple n'est pas réel, juste pour cette question.

alors que je suis d'accord il semble similaire, c'est une différence dans le problème qu'il cherche à résoudre. aussi il est difficile de comprendre à partir de cette question de savoir comment elle pourrait s'appliquer à celui-ci.
Pourquoi ne pas faire PeoplePhoneDto ont un People et Phone membre?
Parce que ce n'est pas ce que je veux exposer.
Vote pour rouvrir, - tandis que je pense que stackoverflow.com/questions/12429210/... est un doublon, il (avec sa seule réponse) semblent un peu trop localisé pour être considéré comme canonique. Il existe un précédent pour dupliquer questions ne comptant pas s'ils n'étaient pas répondu assez bien pour régler la question.

InformationsquelleAutor Bart Calixto | 2014-01-28

automapper c#

89

Vous ne pouvez pas directement de la carte de nombreuses sources pour une seule destination - vous devez demander les cartes une par une, comme décrit dans Andrew Whitaker réponse. Donc, vous devez définir tous les mappages:
```
Mapper.CreateMap<People, PeoplePhoneDto>();
Mapper.CreateMap<Phone, PeoplePhoneDto>()
        .ForMember(d => d.PhoneNumber, a => a.MapFrom(s => s.Number));
```
Alors créer de l'objet de destination par l'une de ces correspondances, et d'appliquer les autres mappages pour objet créé. Et cette étape peut être simplifié avec extension très simple méthode:
```
public static TDestination Map<TSource, TDestination>(
    this TDestination destination, TSource source)
{
    return Mapper.Map(source, destination);
}
```
L'utilisation est très simple:
```
var dto = Mapper.Map<PeoplePhoneDto>(people)
                .Map(phone);
```
- exactement ce que je cherchais! merci!!!!
- Il s'agit d'une abstraction IMapper au cours de AutoMapper à la carte de plusieurs sources dans une seule destination que j'utilise.
- Berezovskiy, j'ai créé les mappages, ajout de la méthode d'extension dans PeoplePhoneDto classe, et copie-collé de votre utilisation (I. e., Je copie-collé tout ce qui est nécessaire), mais j'obtiens un "Pas de surcharge de la méthode de la Carte prend 1 erreur" argument. Ce qui me manque? Je suis en utilisant Automapper 4.2.1.
- assurez-vous que votre Map méthode d'extension est visible au point de vous faire de la cartographie (pour corriger l'aide de la directive est ajouté)
- Ok, got it (violon).
- C'est bon, mais je n'aime pas utiliser de Carte statique en raison de ne pas être en mesure de s'en moquer, donc je vais essayer d'ilyas Imapper abstraction
- Sera-ce de créer la DTO de Classe 2 fois pour chaque carte ou juste une fois?
InformationsquelleAutor Sergey Berezovskiy
17

Vous pouvez utiliser un Tuple pour cela:
```
Mapper.CreateMap<Tuple<People, Phone>, PeoplePhoneDto>()
    .ForMember(d => d.FirstName, opt => opt.MapFrom(s => s.Item1.FirstName))
    .ForMember(d => d.LastName, opt => opt.MapFrom(s => s.Item1.LastName))
    .ForMember(d => d.Number, opt => opt.MapFrom(s => s.Item2.Number ));
```
Dans le cas où vous auriez plus de la source de modèles, vous pouvez utiliser une autre représentation (Liste, Dictionnaire, ou autre chose) qui permettra de recueillir tous ces modèles comme une source.

Le code ci-dessus devrait preferaby être placés dans un AutoMapperConfiguration fichier, une seule fois et à l'échelle mondiale et a ensuite utilisé le cas échéant.

AutoMapper par défaut prend en charge une seule source de données. Donc, il n'y a pas de possibilité de régler directement de sources multiples (sans l'emballant dans une collection), car alors comment pourrions-nous savoir ce que dans le cas si, par exemple, deux modèles de la source ont des propriétés avec les mêmes noms?

Il y a cependant quelques solution pour y parvenir:
```
public static class EntityMapper
{
    public static T Map<T>(params object[] sources) where T : class
    {
        if (!sources.Any())
        {
            return default(T);
        }

        var initialSource = sources[0];

        var mappingResult = Map<T>(initialSource);

        //Now map the remaining source objects
        if (sources.Count() > 1)
        {
            Map(mappingResult, sources.Skip(1).ToArray());
        }

        return mappingResult;
    }

    private static void Map(object destination, params object[] sources)
    {
        if (!sources.Any())
        {
            return;
        }

        var destinationType = destination.GetType();

        foreach (var source in sources)
        {
            var sourceType = source.GetType();
            Mapper.Map(source, destination, sourceType, destinationType);
        }
    }

    private static T Map<T>(object source) where T : class
    {
        var destinationType = typeof(T);
        var sourceType = source.GetType();

        var mappingResult = Mapper.Map(source, sourceType, destinationType);

        return mappingResult as T;
    }
}
```
Et puis:
```
var peoplePhoneDto = EntityMapper.Map<PeoplePhoneDto>(people, phone);
```
Mais pour être tout à fait honnête, même si je suis en utilisant AutoMapper depuis déjà quelques années, je n'ai jamais eu besoin d'utiliser la cartographie à partir de plusieurs sources.
Dans le cas lorsque, par exemple, j'avais besoin de plusieurs modèles d'affaires dans ma vue unique modèle, j'ai simplement intégré ces modèles dans le modèle de vue de classe.

Si dans votre cas, il devrait ressembler à ceci:
```
public class PeoplePhoneDto {
    public People People { get; set; }
    public Phone Phone { get; set; }
}
```
- Donc, je dois créer un tuple avant de faire le mapping, je me demandais quels sont les avantages réels de automapper... le son un peu exagéré. Est-il un moyen d'éviter de créer un autre type (tuple, dic, etc) ?
- merci pour votre réponse, il me conduit à comprendre beaucoup de choses sur automapper. C'est que, quand vous exposer API vous soigneusement les modèles de données de façon à ce que, parfois, avoir intégré les modèles ne sont pas souhaités parce que vous transférez votre domaine, liés à des problèmes d'un consommateur et je suis en train de le rendre facile pour les clients à consommer sans les types imbriqués. Si c'était pour mon propre usage interne, je vais aller de l'avant avec l'option intégrée pour sûr.
- Le PeoplePhoneDto vous l'avez suggéré, semble bon, mais je pense toujours que la cartographie à partir de sources multiples est utile, notamment en vue de cartographie des modèles. Je pense que la plupart des scénarios du monde réel besoin de sources multiples afin de construire un modèle de vue. Je suppose que vous pouvez créer des modèles de vue qui ne sont pas aplatis pour contourner le problème, mais je pense que c'est une bonne idée de créer les modèles de vue sans se soucier de ce que le schéma d'entreprise ressemble.
- Aussi ne automapper de soins de quel ordre les types sont en cours dans le tuple? est Tuple<People, Phone> le même que Tuple<Phone, People>?
- expose le premier argument de type comme Item1, la seconde Item2, etc. En ce sens, l'ordre des questions.
- Quant à vous de ne jamais avoir à la carte à partir de plusieurs sources: ce sera un problème à chaque fois que vous avez une source avec imbriqué/plusieurs objets qui ont besoin d'être aplatie dans la destination, ce qui rend cette sceniario assez commun, je dirais (sauf si vous utilisez les mêmes classes au sein des différentes couches, que je ne recommanderais pas le faire)
InformationsquelleAutor Paweł Bejger

Si vous avez un scénario lorsque le type de destination doit être mappé à partir de l'une des sources et que vous souhaitez utiliser linq projections, vous pouvez effectuer les opérations suivantes.

    Mapper.CreateMap<People, PeoplePhoneDto>(MemberList.Source);
    Mapper.CreateMap<Phone, PeoplePhoneDto>(MemberList.Source)
          .ForMember(d => d.PhoneNumber, a => a.MapFrom(s => s.Number));

    CreateMap<PeoplePhoneDto,(People,Phone)>(MemberList.Destination)
           .ForMember(x => x.Item1, opts => opts.MapFrom(x => x))
           .ForMember(x => x.Item2, opts => opts.MapFrom(x => x.PhoneNumber))
           .ReverseMap();

J'avais besoin de ce, principalement pour la croix-appliquer des requêtes de ce genre.

       var dbQuery =
          from p in _context.People
          from ph in _context.Phones
             .Where(x => ...).Take(1)
          select ValueTuple.Create(p, ph);
       var list = await dbQuery
          .ProjectTo<PeoplePhoneDto>(_mapper.ConfigurationProvider)
          .ToListAsync();

InformationsquelleAutor Gevorg Narimanyan

Vous devez vous connecter pour publier un commentaire.