AutoMapper कई स्रोतों से परिवर्तित होते हैं

Question 1

मान लें कि मेरे पास दो मॉडल कक्षाएं हैं:

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

इसके अलावा एक वर्ग फोन है:

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

और मैं इस तरह एक PeoplePhoneDto में परिवर्तित करना चाहते हैं:

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

चलो मेरे नियंत्रक में कहते हैं:

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

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

मुझे इस परिदृश्य के लिए कोई उदाहरण नहीं मिल रहा है। क्या यह संभव है ?

नोट: उदाहरण वास्तविक नहीं है, बस इस प्रश्न के लिए।

Question 2

आप कई स्रोतों को सीधे सिंगल डेस्टिनेशन पर मैप नहीं कर सकते हैं - आपको एक-एक करके नक्शे को लागू करना चाहिए, जैसा कि एंड्रयू व्हिटकर उत्तर में वर्णित है । तो, आपको सभी मैपिंग को परिभाषित करना होगा:

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

फिर इनमें से किसी भी मैपिंग द्वारा डेस्टिनेशन ऑब्जेक्ट बनाएं, और अन्य मैपिंग को बनाए गए ऑब्जेक्ट पर लागू करें। और इस कदम को बहुत ही सरल विस्तार विधि से सरल बनाया जा सकता है:

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

उपयोग बहुत सरल है:

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

Question 3

आप इसके लिए उपयोग कर सकते हैं Tuple:

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

यदि आपके पास अधिक स्रोत मॉडल हैं तो आप एक अलग प्रतिनिधित्व (सूची, शब्दकोश या कुछ और) का उपयोग कर सकते हैं जो स्रोत के रूप में इन सभी मॉडलों को एक साथ इकट्ठा करेंगे।

उपर्युक्त कोड को कुछ ऑटोमैपररॉन्फ़िगरेशन फ़ाइल में प्रेफैबी को रखा जाना चाहिए, एक बार और विश्व स्तर पर सेट किया गया है और फिर जब लागू किया जाता है।

डिफ़ॉल्ट रूप से AutoMapper केवल एक डेटा स्रोत का समर्थन करता है। तो सीधे कई स्रोतों को सेट करने की कोई संभावना नहीं है (एक संग्रह में इसे लपेटे बिना) क्योंकि तब हमें कैसे पता चलेगा कि अगर दो स्रोत मॉडल में समान नाम वाले गुण हैं तो क्या होगा?

हालांकि इसे प्राप्त करने के लिए कुछ समाधान है:

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

और तब:

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

लेकिन काफी ईमानदार होने के बावजूद, भले ही मैं पहले से ही कुछ वर्षों से ऑटोमैपर का उपयोग कर रहा हूं, लेकिन मुझे कई स्रोतों से मैपिंग का उपयोग करने की आवश्यकता नहीं है। ऐसे मामलों में जब उदाहरण के लिए मुझे अपने एकल दृश्य मॉडल में कई व्यावसायिक मॉडल की आवश्यकता होती है, मैं बस इन मॉडलों को दृश्य मॉडल वर्ग के भीतर एम्बेड करता हूं।

तो आपके मामले में ऐसा लगेगा:

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

Question 4

मैं नीचे के रूप में एक विस्तार विधि लिखूंगा:

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

तब उपयोग होगा:

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

Question 5

शायद यह एक पुरानी पोस्ट लगती है, लेकिन हो सकता है कि कुछ लोग अभी भी उसी मुद्दे से जूझ रहे हों, AutoMapper IMapper Map function प्रलेखन का जिक्र करते हुए , हम नए स्रोत से मैपिंग के लिए उसी मौजूदा डेस्टिनेशन ऑब्जेक्ट का फिर से उपयोग कर सकते हैं, बशर्ते कि आपने पहले ही बनाया हो प्रोफ़ाइल में गंतव्य के लिए प्रत्येक स्रोत के लिए मानचित्र, फिर आप इस सरल एक्सटेंशन विधि का उपयोग कर सकते हैं:

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

कृपया ध्यान दें कि मैंने गंतव्य प्रकार के लिए एक बाधा बनाई है जो कहती है कि यह तत्काल-सक्षम प्रकार होना चाहिए। यदि आपका प्रकार default(TDestination)इसके बजाय उस उपयोग की तरह नहीं है new TDestination()।

चेतावनी : इस प्रकार की मैपिंग कभी-कभी थोड़ी खतरनाक होती है क्योंकि गंतव्य मैपिंग गुणों को कई स्रोतों से अधिलेखित किया जा सकता है और समस्या को बड़े ऐप्स में ट्रेस करना सिरदर्द हो सकता है, एक ढीला वर्कआउट है जिसे आप लागू कर सकते हैं, आप नीचे के रूप में कर सकते हैं, लेकिन फिर से यह एक ठोस समाधान नहीं है:

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

Question 6

यदि आपके पास एक परिदृश्य है जब गंतव्य प्रकार को स्रोतों में से एक से मैप किया जाना चाहिए और आप linq अनुमानों का उपयोग करना चाहते हैं, तो आप निम्नलिखित कर सकते हैं।

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

मुझे इस तरह से क्रॉस क्रॉस क्वेश्चन के लिए इसकी जरूरत थी।

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

Question 7

बहुत सारे विकल्प पहले से ही प्रदान किए गए हैं, लेकिन उनमें से कोई भी वास्तव में फिट नहीं है जो मैं चाहता था। मैं कल रात सो रहा था और सोचा था:

कहते हैं कि आप अपने दो वर्गों, Peopleऔर Phoneकरने के लिए मैप करना चाहते हैंPeoplePhoneDto

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

आपको वास्तव में ऑटोमैपर उद्देश्यों के लिए एक और आवरण वर्ग की आवश्यकता है।

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

और फिर मानचित्रण को परिभाषित करें:

CreateMap<PeoplePhone, PeoplePhoneDto>()

और इसका उपयोग करें

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