AutoMapper-Konvertierung aus mehreren Quellen

Angenommen, ich habe zwei Modellklassen:

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

Haben Sie auch eine Klasse Telefon:

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

Und ich möchte wie folgt in ein PeoplePhoneD konvertieren:

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

Sagen wir in meinem Controller, den ich habe:

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

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

Ich kann anscheinend kein Beispiel für dieses Szenario finden. Ist das möglich ?

Hinweis: Das Beispiel ist nur für diese Frage nicht real.

Sie können nicht viele Quellen direkt einem einzelnen Ziel zuordnen. Sie sollten die Karten einzeln anwenden, wie in der Antwort von Andrew Whitaker beschrieben . Sie müssen also alle Zuordnungen definieren:

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

Erstellen Sie dann das Zielobjekt mit einer dieser Zuordnungen und wenden Sie andere Zuordnungen auf das erstellte Objekt an. Und dieser Schritt kann mit einer sehr einfachen Erweiterungsmethode vereinfacht werden:

public static TDestination Map<TSource, TDestination>(
    this TDestination destination, TSource source)
{
    return Mapper.Map(source, destination);
}

Die Verwendung ist sehr einfach:

var dto = Mapper.Map<PeoplePhoneDto>(people)
                .Map(phone);

Sie könnten ein Tupledafür verwenden:

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

Falls Sie mehr Quellmodelle hätten, können Sie eine andere Darstellung (Liste, Wörterbuch oder etwas anderes) verwenden, die alle diese Modelle als Quelle zusammenfasst.

Der obige Code sollte vorzugsweise in einer AutoMapperConfiguration-Datei abgelegt, einmal und global festgelegt und dann gegebenenfalls verwendet werden.

AutoMapper unterstützt standardmäßig nur eine einzige Datenquelle. Es gibt also keine Möglichkeit, mehrere Quellen direkt festzulegen (ohne sie in eine Sammlung einzuschließen), denn wie würden wir dann wissen, was passiert, wenn beispielsweise zwei Quellmodelle Eigenschaften mit demselben Namen haben?

Es gibt jedoch einige Problemumgehungen, um dies zu erreichen:

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

Und dann:

var peoplePhoneDto = EntityMapper.Map<PeoplePhoneDto>(people, phone);

Aber um ganz ehrlich zu sein, obwohl ich AutoMapper bereits seit einigen Jahren verwende, musste ich nie Mapping aus mehreren Quellen verwenden. In Fällen, in denen ich beispielsweise mehrere Geschäftsmodelle in meinem Einzelansichtsmodell benötigte, habe ich diese Modelle einfach in die Ansichtsmodellklasse eingebettet.

In Ihrem Fall würde es also so aussehen:

public class PeoplePhoneDto {
    public People People { get; set; }
    public Phone Phone { get; set; }
}

Vielleicht klingt es nach einem alten Beitrag, aber es gibt möglicherweise einige Leute, die immer noch mit demselben Problem zu kämpfen haben. In der Dokumentation zur AutoMapper IMapper Map-Funktion können wir dasselbe vorhandene Zielobjekt für die Zuordnung aus einer neuen Quelle wiederverwenden, vorausgesetzt, Sie haben bereits einen erstellt Wenn Sie für jede Quelle ein Ziel im Profil zuordnen, können Sie diese einfache Erweiterungsmethode verwenden:

 public static class MappingExtentions
    {
        public static TDestination Map<TDestination>(this IMapper mapper, params object[] sources) where TDestination : new()
        {
            return Map(mapper, new TDestination(), sources);
        }

        public static TDestination Map<TDestination>(this IMapper mapper, TDestination destination, params object[] sources) where TDestination : new()
        {
            if (!sources.Any())
                return destination;

            foreach (var src in sources)
                destination = mapper.Map(src, destination);

            return destination;
        }
    }

Bitte beachten Sie, dass ich eine Einschränkung für den Zieltyp erstellt habe, die besagt, dass es sich um einen instanziierbaren Typ handeln muss. Wenn Ihr Typ nicht so ist, verwenden Sie default(TDestination)stattdessen new TDestination().

Warnung : Diese Art der Zuordnung ist manchmal etwas gefährlich, da die Eigenschaften der Zielzuordnung möglicherweise von mehreren Quellen überschrieben werden und das Nachverfolgen des Problems in größeren Apps Kopfschmerzen bereiten kann. Es gibt eine lose Problemumgehung, die Sie anwenden können. Sie können dies jedoch wie folgt tun wieder ist es überhaupt keine feste Lösung:

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

    public class Contact
    {
        public string Address { get; set; }
        public string PhoneNumber { get; set; }
        public string Other{ get; set; }
    }


    public class PersonContact
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Address{ get; set; }
        public string PhoneNumber { get; set; }
    }

    public class PersonMappingProfile : MappingProfile
    {
        public PersonMappingProfile()
        {
            this.CreateMap<Person, PersonContact>();

            
            this.CreateMap<Phone, PersonContact>()
                .ForMember(dest => dest.PhoneNumber, opt => opt.MapFrom((src, dest) => dest.PhoneNumber ?? src.PhoneNumber)) // apply mapping from source only if the phone number is not already there, this way you prevent overwriting already initialized props
                .ForAllOtherMembers(o => o.Ignore());
        }
    }

Wenn Sie ein Szenario haben, in dem der Zieltyp aus einer der Quellen zugeordnet werden soll und Sie Linq-Projektionen verwenden möchten, können Sie Folgendes tun.

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

Ich brauchte dies hauptsächlich für Cross-Apply-Abfragen wie diese.

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

Ich würde eine Erweiterungsmethode wie folgt schreiben:

    public static TDestination Map<TSource1, TSource2, TDestination>(
        this IMapper mapper, TSource1 source1, TSource2 source2)
    {
        var destination = mapper.Map<TSource1, TDestination>(source1);
        return mapper.Map(source2, destination);
    }

Dann wäre die Verwendung:

    mapper.Map<People, Phone, PeoplePhoneDto>(people, phone);

Es gibt bereits viele Optionen, aber keine passt wirklich zu dem, was ich wollte. Ich bin letzte Nacht eingeschlafen und hatte den Gedanken:

Nehmen wir an, Sie möchten Ihre beiden Klassen zuordnen Peopleund PhoneaufPeoplePhoneDto

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

+

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

=

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

Alles, was Sie wirklich brauchen, ist eine weitere Wrapper-Klasse für Automapper-Zwecke.

public class PeoplePhone {
    public People People {get;set;}
    public Phone Phone {get;set;}
}

Und dann definieren Sie das Mapping:

CreateMap<PeoplePhone, PeoplePhoneDto>()

Und benutze es

var dto = Map<PeoplePhoneDto>(new PeoplePhone
{
    People = people,
    Phone = phone,
});