Comment carte IEnumerable à la Liste à l'aide de AutoMapper

Je suis en train de carte IEnumerable à la Liste. Je ne suis pas sûr de savoir comment le faire fonctionner. Voici ce que j'ai essayé jusqu'à présent.

J'obtiens une erreur "configuration Personnalisée pour les membres est pris en charge uniquement pour le premier niveau différents membres sur un type."

Source: IEnumerable<Source>
Target: List<Target>

AutoMapper.Mapper.Map(sourceIEnum, TargetList);

Mapper.CreateMap<IEnumerable<Source>, List<Target>>()
    .ForMember(f => f, mp => mp.MapFrom(
                                    mfrom => mfrom.Select(s => AutoMapper.Mapper.Map(s, new Target())
                                ).ToList())
              );

Mapper.CreateMap<Source, Target>()
    .ForMember(f => f.TargetPropertyA, mp => mp.MapFrom(mfrom => mfrom.FromA.Value))
    .ForMember(f => f.TargetPropertyB, mp => mp.MapFrom(mfrom => mfrom.FromB.Value))
    .ForMember(f => f.TargetPropertyC, mp => mp.MapFrom(mfrom => mfrom.FromC.Value))
    .ForMember(f => f.InnerObjectTarget, mp => mp.MapFrom(
                                    mfrom => mfrom.Select(s => AutoMapper.Mapper.Map(s, new InnerObjectTarget())
                                ).ToList())
              );    

Mapper.CreateMap<SourceInner, TargetInner>()
        .ForMember(f => f.TargetInnerPropA, m => m.MapFrom(source => source.InnerA))
        .ForMember(f => f.TargetInnerPropB, m => m.MapFrom(source => source.InnerB))
        .ForMember(f => f.TargetInnerPropC, m => m.MapFrom(source => source.InnerC));

OriginalL'auteur CoolArchTek | 2014-04-05

automapper c#

5

Il y a plusieurs façons de carte un IEnumerable<Source> à un IEnumerable<Target>. Je vais vous montrer les trois plus pratiques.

Prendre le Base de données AdventureWorks (2008R2) comme un exemple, j'ai défini trois DTO classes:
```
class ProductModelDto
{
    public string Name { get; set; }
    public IEnumerable<ProductDto> Products { get; set; }
}

class ProductDto
{
    public string Name { get; set; }
    public string Number { get; set; }
    public IEnumerable<ProductReviewDto> ProductReviews { get; set; }
}

class ProductReviewDto
{
    public string ReviewerName { get; set; }
    public string Email { get; set; }
}
```
Voici le seul cartographie que j'ai défini:
```
Mapper.CreateMap<ProductModel, ProductModelDto>();
Mapper.CreateMap<Product, ProductDto>()
      .ForMember(dto => dto.Number, m => m.MapFrom(p => p.ProductNumber));
Mapper.CreateMap<ProductReview, ProductReviewDto>()
      .ForMember(dto => dto.Email, m => m.MapFrom(pr => pr.EmailAddress));
```
Juste une requête:
```
//A ProductModel having a Product with ProductReviews
var query = db.ProductModels.Where(pm => pm.ProductModelID == 64);
```
Maintenant les moyens les plus commodes, à mon avis, à la carte la source ProductModels à IEnumerable<ProductModelDto> sont ces trois:
```
1. query.Select(Mapper.Map<ProductModelDto>)
2. Mapper.Map<List<ProductModelDto>>(query)
3. query.ProjectTo<ProductModelDto>() (Project().To<> prior to v. 4.1.0)
```
Et si vous ne ToList(), vous avez mappé IEnumerable à List.

Le résultat est le même pour tous les trois alternatives:
```
- HL Mountain Pedal
  - HL Mountain Pedal; PD-M562
    - David; [email protected]
    - Jill; [email protected]
```
Comme vous le voyez, AutoMapper n'a pas besoin explicite de la cartographie des définitions pour les IEnumerables. Pas pour le haut niveau et non pas pour les collections imbriquées. Il correspond également une collection imbriquées lorsque les noms sont identiques à la source et de la cible les classes et une correspondance est définie pour les éléments de la collection.

Cas 3 est un cas spécial. Il projette la IQueryable à la cible, qui est encore un IQueryable. Les prédicats appliquée après la cartographie sont toujours traduits de la requête SQL et essaie de sélectionner uniquement les champs de la base de données qui sont nécessaires pour la projection. Ce dernier ne réussit pas toujours quand les Dto sont imbriqués si, comme dans ce cas. Linq to SQL est apparu pour exécuter deux requêtes avec l'option 3 (mais trois pour 1 et 2).

numéro 1 dans votre liste, ne semble pas fonctionner, vous avez manqué quelque chose dans la syntaxe? J'étais de retour IEnumerable... (la source)
Veuillez être plus précis.
de la requête.Sélectionnez(Mappeur.Map<ProductModelDto>) je suis le seul à vous demander si vous avez manqué certains soft de crochets ou de quelque chose, c'est tout... en quelque sorte une double vérification. Comme je suis d'essayer d'obtenir un IEnumerable liste (source) pour les convertir.
deosn pas l'air de fonctionner vous suggère d'aller à l'erreur. La syntaxe est OK, c'est équivalent à query.Select(x => Mapper.Map<ProductModelDto>(x)).

OriginalL'auteur Gert Arnold
2

Tant que Source à Cible correspondance est définie, vous n'avez pas besoin de définir IEnumerable<Source> à List<Target> cartographie explicitement.

Automapper est assez intelligent pour la carte de base des collections automatiquement (Liste, IEnumerable, Collection etc.) si la collection de types d'éléments sont mappés. donc, supprimer tout le code entre la collecte de cartographie et d'essayer de nouveau.

Cet extrait..
```
Mapper.CreateMap<IEnumerable<Source>, List<Target>>()
    .ForMember(f => f, mp => mp.MapFrom(
                                    mfrom => mfrom.Select(s => AutoMapper.Mapper.Map(s, new Target())
                                ).ToList())
              );
```
OriginalL'auteur Raja Nadar

Vous devez vous connecter pour publier un commentaire.