AutoMapper: "बाकी ध्यान न दें"?

Question

क्या ऑटोमैपर को यह बताने का कोई तरीका है कि सभी संपत्तियों की अनदेखी करें, जिन्हें स्पष्ट रूप से मैप किया गया है?

मेरे पास बाहरी डीटीओ कक्षाएं हैं जो बाहर से बदलने की संभावना है और मैं प्रत्येक संपत्ति को स्पष्ट रूप से अनदेखा करने के लिए निर्दिष्ट करने से बचना चाहता हूं, क्योंकि नई संपत्तियों को जोड़ने से कार्यक्षमता (कारण अपवाद) टूट जाएगी, जब वे मुझे अपनी वस्तुओं में मैप करने की कोशिश करेंगे।

Comments

ValueInjecter valueinjecter.codeplex.com/documentation के साथ, आप ऐसे मान बनाते हैं, जिसमें उनकी मैपिंग एल्जीथिथ्म और विशिष्ट गुणों के बीच मैप होती है, और वे बाकी संपत्तियों के बारे में परवाह नहीं करते हैं

— ओमू

ऑटोमेपर> संस्करण 5 का उपयोग करने वालों के लिए, विवरणों को देखने के लिए नीचे छोड़ें.ForAllOtherMembers(opts => opts.Ignore())

— जैक उकलेजा

@Schneider ".ForAllOtherMembers (opts => opts.Ignore ())" विस्तार "IgnoreAllNonExisting" के साथ यहां अलग है, मुख्य अंतर यह है कि यदि आपने संपत्ति को कॉन्फ़िगर नहीं किया है, तो ".ForAllOtherMembers (opts.Ignore) के साथ"। )) "आपको कुछ भी मैप नहीं मिलेगा। स्पष्ट रूप से कॉन्फ़िगर संपत्ति के बिना "IgnoreAllNonExisting" का उपयोग करें, आपको अभी भी मूल्य के साथ कुछ संपत्ति मैप (समान नाम वाले गुण) मिलते हैं।

— ड्रैगन

हाँ। ForAllOtherMembers जवाब है। IgnoreUnmapped उत्तर कुछ भी नहीं करते हैं सिवाय इसके कि विन्यास-वैध-अभिकर्ता को पारित करने के लिए, क्योंकि अनमैप किए गए सदस्यों को वैसे भी अनदेखा किया जाता है।

— N73k

ध्यान देने योग्य बात यह है कि ऐसा करते समय, आप स्पष्ट रूप से मैप किए जा रहे वर्गों में संभावित रूप से प्रासंगिक या महत्वपूर्ण परिवर्तनों को छिपाते हैं। जब भी मैप की गई कक्षा में बदलाव होता है, हर संपत्ति के लिए स्पष्ट मैपिंग आपको टूटे हुए परीक्षण के साथ छोड़ देगी, जिससे आप उसका सही मूल्यांकन कर सकें। (यह देखते हुए कि आपके पास AssertConfigurationIsValid()कॉल करने का एक परीक्षण है ) इस वजह से, मैं एक एंटीपैटर्न पर "बाकी की उपेक्षा" पर विचार करता हूं।

— Arve Systad

Answer 1

यह एक विस्तार विधि है जो मैंने लिखा है कि गंतव्य पर सभी गैर मौजूदा गुणों की उपेक्षा करता है। यह सुनिश्चित नहीं है कि यह अभी भी उपयोगी होगा क्योंकि यह प्रश्न दो साल से अधिक पुराना है, लेकिन मैं एक ही मुद्दे में भाग गया जिसमें बहुत सारे मैनुअल इग्नोर कॉल को जोड़ना था।

public static IMappingExpression<TSource, TDestination> IgnoreAllNonExisting<TSource, TDestination>
(this IMappingExpression<TSource, TDestination> expression)
{
    var flags = BindingFlags.Public | BindingFlags.Instance;
    var sourceType = typeof (TSource);
    var destinationProperties = typeof (TDestination).GetProperties(flags);

    foreach (var property in destinationProperties)
    {
        if (sourceType.GetProperty(property.Name, flags) == null)
        {
            expression.ForMember(property.Name, opt => opt.Ignore());
        }
    }
    return expression;
}

उपयोग:

Mapper.CreateMap<SourceType, DestinationType>()
                .IgnoreAllNonExisting();

अद्यतन : जाहिर तौर पर यह सही ढंग से काम नहीं करता है यदि आपके पास कस्टम मैपिंग है क्योंकि यह उन्हें अधिलेखित करता है। मुझे लगता है कि यह अभी भी काम कर सकता है अगर कॉल IgnoreAllNonExisting पहले और फिर बाद में कस्टम मैपिंग।

schdr के पास एक समाधान है (इस प्रश्न के उत्तर के रूप में) जो यह Mapper.GetAllTypeMaps()पता लगाने के लिए उपयोग करता है कि कौन से गुण अनमैप्ड हैं और ऑटो उन्हें अनदेखा करते हैं। मेरे लिए एक अधिक मजबूत समाधान की तरह लगता है।

Comments

मैंने कुछ समय के लिए AutoMapper का उपयोग नहीं किया है, लेकिन अगर यह आपके लिए काम करता है तो मैं आपके उत्तर को स्वीकार करूंगा :)।

— इगोर ब्रेजक

धन्यवाद!! मुझे यह बहुत आसान लगा। व्यक्तिगत रूप से गुणों की अनदेखी मेरी स्थिति में ऑटोमैपर का उपयोग करने के उद्देश्य को हरा रही थी।

— डेनियल रॉबिन्सन

एक के लिए अगला जवाब देखें कि ओवरराइट समस्या नहीं है

— जेसन कॉयेन

यह तरीका autoMapper नेटिव कोड पर होना चाहिए! बहुत बढिया आपको धन्यवाद!

— फेलिप ओरियानी

FYI करें, जिमी ने खुद (AutoMapper के लेखक) ने नीचे टिप्पणी की है कि @ नाज़िम का उत्तर संस्करण 5+ के लिए सही है

— वर्थ 7

Answer 2

जो मुझे समझ में आया वह यह था कि गंतव्य पर फ़ील्ड्स हैं जिनके स्रोत में मैप्ड फ़ील्ड नहीं है, यही वजह है कि आप उन मैप किए गए गंतव्य फ़ील्डों को अनदेखा करने के तरीके खोज रहे हैं।

इन विस्तार विधि को लागू करने और उपयोग करने के बजाय आप बस उपयोग कर सकते हैं

Mapper.CreateMap<sourceModel, destinationModel>(MemberList.Source);  

अब ऑटोमेकर जानता है कि उसे केवल यह सत्यापित करने की आवश्यकता है कि सभी स्रोत फ़ील्ड मैप किए गए हैं, लेकिन अन्य तरीके से नहीं।

आप भी उपयोग कर सकते हैं:

Mapper.CreateMap<sourceModel, destinationModel>(MemberList.Destination);  

Comments

इस उत्तर में अधिक उत्थान होना चाहिए, शायद उत्तर के रूप में भी चिह्नित किया जाए। इससे मेरी समस्या हल हो गई और इसी तरह से MemberList.Destinationऑप्स समस्या का समाधान हो जाएगा।

— टेड हेन्सन

यदि आप स्रोत और गंतव्य दोनों पर कुछ गुणों को अनदेखा करना चाहते हैं तो यह काम नहीं करेगा :)

— RealWillyWoka

बाद में आने वाले किसी के लिए, यह 5.0 के लिए सही उत्तर है

— जिमी बोगार्ड

निफ्टी दिखता है, लेकिन मेरे लिए काम नहीं करता था .. मैंने स्रोत और गंतव्य की कोशिश की, लेकिन यह उसी संपत्ति के बारे में शिकायत करता रहता है जिसमें एक नक्शा गायब है

— सोनिक सोल

6.0.2 का उपयोग करना और यह कार्य अवधि नहीं है। कोई भी संपत्ति जिसे गंतव्य से स्रोत तक मैप नहीं किया गया है, स्रोत में गुणों को शून्य और 0s के साथ अधिलेखित करें। प्लस कोड यह स्पष्ट नहीं करता है कि आप क्या कर रहे हैं, खासकर यदि आप एक टीम में काम कर रहे हैं। इसलिए मैं इस कोड को बहुत नापसंद करता हूं, और मैं सुझाए गए उत्तर "IgnoreAllNonExisting" जैसे पसंद शब्द क्यों पसंद करता हूं

— sksallaj

Answer 3

मैंने अपडेट किया है कि किसी भी मौजूदा नक्शे को अधिलेखित नहीं करने के लिए कैन गेनर का विस्तार।

public static IMappingExpression<TSource, TDestination> 
    IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var sourceType = typeof (TSource);
    var destinationType = typeof (TDestination);
    var existingMaps = Mapper.GetAllTypeMaps().First(x => x.SourceType.Equals(sourceType) && x.DestinationType.Equals(destinationType));
    foreach (var property in existingMaps.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

उपयोग:

Mapper.CreateMap<SourceType, DestinationType>()
                .ForMember(prop => x.Property, opt => opt.MapFrom(src => src.OtherProperty))
                .IgnoreAllNonExisting();

Comments

+1, इस समाधान को पोस्ट करने के लिए धन्यवाद। जब मैंने goo.gl/rG7SL में समाधान का उपयोग किया , तब तक मुझे अजीब घंटे लगने में घंटों लग गए , जब तक कि मैं इस पद पर दोबारा ठोकर नहीं खाता ।

— नॉर्डिन

मैं इस पर नीचे योहन की विधि का सुझाव देता हूं। कुछ कोने के मामले हैं जो यह काम नहीं करते हैं यह प्रकट होता है।

— जॉन बार्कर

क्या यह AutoMapper 4.2 में किया जा सकता है? ( Mapper.GetAllTypeMaps()पदावनत किया जाता है)

— मृषाला

AutoMapper 5+ संस्करण के लिए बस के Mapper.GetAllTypeMaps()साथ बदलें Mapper.Configuration.GetAllTypeMaps()। यहाँ संदर्भ github.com/AutoMapper/AutoMapper/issues/1252 है

— सर्गेई जी।

इसे पढ़ने वाले नए लोगों के लिए। यह उत्तर AutoMapper 2 के लिए है और इस टिप्पणी को लिखने के समय हम संस्करण 6 पर हैं। यह एक हैक है और बहुत अधिक स्वच्छ तरीके से सदस्य सूची का उपयोग कर रहा है। गितुब अंक 1839 और एक बेहतर समाधान देखें। github.com/AutoMapper/AutoMapper/issues/1839 तो उदाहरण: stackoverflow.com/a/31182390/3850405

— Ogglas

Answer 4

मैं इसे निम्नलिखित तरीके से करने में सक्षम हूं:

Mapper.CreateMap<SourceType, DestinationType>().ForAllMembers(opt => opt.Ignore());
Mapper.CreateMap<SourceType, DestinationType>().ForMember(/*Do explicit mapping 1 here*/);
Mapper.CreateMap<SourceType, DestinationType>().ForMember(/*Do explicit mapping 2 here*/);
...

नोट: मैं AutoMapper v.2.0 का उपयोग कर रहा हूं।

Comments

आपको बहुत - बहुत धन्यवाद! यह एक जादू की तरह काम करता है। मैंने पहले कॉल को चेन करने की कोशिश की, लेकिन ForAllMembers सिर्फ शून्य लौटाते हैं :( यह स्पष्ट नहीं था कि पूर्ववर्ती IgnoreAll को बाद में संशोधित किया जा सकता है।

— SeriousM

मुझे यह तरीका पसंद नहीं है .. यदि आपके पास 50 सदस्य हैं, और आप 25 को अनदेखा करना चाहते हैं .. तो अगर आप अभी भी 25 सदस्यों को अनदेखा करते हैं, तो ऑटोमैपर की बात क्या है। यदि नाम मैच करते हैं, और ऐसे गुण हैं जो मेल नहीं खाते हैं .. तो क्यों न स्वचालित रूप से बताएं कि अनमैप्ड संपत्तियों पर मेल न करें और सभी टाइपिंग पास करें?

— sksallaj

Answer 5

AutoMapper का संस्करण 5.0.0-बीटा -1 ForAllOtherMembersविस्तार विधि का परिचय देता है ताकि आप अब ऐसा कर सकें:

CreateMap<Source, Destination>()
    .ForMember(d => d.Text, o => o.MapFrom(s => s.Name))
    .ForMember(d => d.Value, o => o.MapFrom(s => s.Id))
    .ForAllOtherMembers(opts => opts.Ignore());

ध्यान रखें कि प्रत्येक संपत्ति को स्पष्ट रूप से मैप करने का एक फायदा है क्योंकि जब आप किसी संपत्ति को मैप करना भूल जाते हैं तो चुपचाप असफल होने की मैपिंग की समस्या कभी नहीं आएगी।

शायद आपके मामले में अन्य सभी सदस्यों को अनदेखा करना और TODOवापस आने के लिए जोड़ना और इन स्पष्ट बदलावों की आवृत्ति के बाद इसे स्पष्ट करना संभव हो सकता है ।

Comments

अद्भुत यह संस्करण 5 तक ले गया। देखो कितने अप-वोट और इस सवाल का जवाब देने की कोशिश की ... ऑटोमेकर के शासन के साथ कुछ गलत है मुझे आश्चर्य है?

— जैक उलेजा

इसके लिए आपको धन्यवाद, मुझे इसे नीचे स्क्रॉल करने में थोड़ी देर लगी लेकिन यह, लेकिन यह पूरी तरह से काम करता है।

— कोबोलस्टिंक

आप ForAllOtherMembers लाइन को पहले भी डाल सकते हैं और चीजें उसी तरह काम करेंगी, जो किसी प्रकार के बेस क्लास कॉन्फ़िगरेशन के लिए अच्छा है।

— N73k

यह अब पसंदीदा तरीका है। आश्चर्य है कि अगर ओपी स्वीकृत उत्तर को बदल सकता है?

— चेस फ्लोरल

क्या स्रोत ऑब्जेक्ट में गुणों को अनदेखा करने के बराबर है? कुछ पसंद है ForAllOtherSourceMembers?

— SuperJMN

Answer 6

AutoMapper 5.0 के रूप में, .TypeMapसंपत्ति IMappingExpressionचली गई है, जिसका अर्थ है कि 4.2 समाधान अब काम नहीं करता है। मैंने एक समाधान बनाया है जो मूल कार्यक्षमता का उपयोग करता है लेकिन एक अलग वाक्यविन्यास के साथ:

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src, Dest>();
    cfg.IgnoreUnmapped();        // Ignores unmapped properties on all maps
    cfg.IgnoreUnmapped<Src, Dest>();  // Ignores unmapped properties on specific map
});

// or add  inside a profile
public class MyProfile : Profile
{
   this.IgnoreUnmapped();
   CreateMap<MyType1, MyType2>();
}

कार्यान्वयन:

public static class MapperExtensions
{
    private static void IgnoreUnmappedProperties(TypeMap map, IMappingExpression expr)
    {
        foreach (string propName in map.GetUnmappedPropertyNames())
        {
            if (map.SourceType.GetProperty(propName) != null)
            {
                expr.ForSourceMember(propName, opt => opt.Ignore());
            }
            if (map.DestinationType.GetProperty(propName) != null)
            {
                expr.ForMember(propName, opt => opt.Ignore());
            }
        }
    }

    public static void IgnoreUnmapped(this IProfileExpression profile)
    {
        profile.ForAllMaps(IgnoreUnmappedProperties);
    }

    public static void IgnoreUnmapped(this IProfileExpression profile, Func<TypeMap, bool> filter)
    {
        profile.ForAllMaps((map, expr) =>
        {
            if (filter(map))
            {
                IgnoreUnmappedProperties(map, expr);
            }
        });
    }

    public static void IgnoreUnmapped(this IProfileExpression profile, Type src, Type dest)
    {
        profile.IgnoreUnmapped((TypeMap map) => map.SourceType == src && map.DestinationType == dest);
    }

    public static void IgnoreUnmapped<TSrc, TDest>(this IProfileExpression profile)
    {
        profile.IgnoreUnmapped(typeof(TSrc), typeof(TDest));
    }
}

Comments

आप एक जंजीर CreateMap<TSource,TDest>()अभिव्यक्ति में इस का उपयोग कैसे करेंगे Profile?

— जम्मेरडिक

इसके लिए धन्यवाद। GetUnmappedPropertyNames विधि स्रोत और गंतव्य दोनों पर, जो किसी रिवर्स मैप पर विराम लगती है, पर सभी अनमैप किए गए प्रॉपर्टी के नाम लौटाता है, इसलिए मुझे यह देखने के लिए इग्नोरयूम्नैप में एक छोटा सा बदलाव करना पड़ा कि क्या अनमैन्ड प्रॉपर्टी स्रोत या गंतव्य पर है और अनदेखा करें तदनुसार। यहाँ समस्या और अद्यतन को प्रदर्शित करने वाली एक फ़िदा है

— Mun

मैंने अपने निष्कर्षों को शामिल करने के लिए अपने उत्तर को अपडेट किया है - मैं स्रोत मैपिंग का उपयोग नहीं करता हूं इसलिए यह इस पार नहीं आया था! धन्यवाद।

— रिचर्ड

यह बिना प्रतिबिंब के पीसीएल पर काम नहीं करता है, गेटप्रॉपर्टी (प्रोपनाम) मौजूद नहीं है।

— जॉर्ज टास्कोस

मैं यह नहीं देखता कि यह प्रश्न का हल कैसे है, या यह कैसे कुछ भी करता है। मैप नहीं गुण पहले से ही ध्यान नहीं दिया जा करने के लिए जा रहे हैं - क्योंकि वे तुच्छ । पोस्टर में कहा गया है, "जब तक आप स्पष्ट रूप से मैप नहीं किए जाते हैं तब तक आप प्रॉप्स को कैसे अनदेखा करते हैं "। इसका मतलब है कि अगर मेरे पास Src.MyProp और Dest.MyProp है, तो उस मैपिंग को अनदेखा किया जाना चाहिए जब तक कि MyProp के लिए MapFrom & ForMember को कोई स्पष्ट कॉल न हो। इसलिए, डिफ़ॉल्ट मैपिंग को अनदेखा करने की आवश्यकता है। केवल एक चीज जो इस समाधान को करती है, वह है विन्यास-वैध-मुखर चीज को पारित करने के लिए - जिसके लिए आपको मैपिंग के लिए किसी भी तरह की आवश्यकता नहीं है।

— N73k

Answer 7

प्रश्न पूछे जाने के बाद कुछ साल हो गए हैं, लेकिन यह विस्तार विधि मुझे स्वतः साफ लगती है, AutoMapper (3.2%) के वर्तमान संस्करण का उपयोग करते हुए:

public static IMappingExpression<TSource, TDestination> IgnoreUnmappedProperties<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var typeMap = Mapper.FindTypeMapFor<TSource, TDestination>();
    if (typeMap != null)
    {
        foreach (var unmappedPropertyName in typeMap.GetUnmappedPropertyNames())
        {
            expression.ForMember(unmappedPropertyName, opt => opt.Ignore());
        }
    }

    return expression;
}

Answer 8

जो संस्करण 4.2.0 और इसके बाद के संस्करण में गैर-स्थिर एपीआई का उपयोग कर रहे हैं , उनके लिए निम्नलिखित विस्तार विधि ( कक्षा में यहां पाई AutoMapperExtensionsजा सकती है) निम्न हैं:

// from http://stackoverflow.com/questions/954480/automapper-ignore-the-rest/6474397#6474397
public static IMappingExpression IgnoreAllNonExisting(this IMappingExpression expression)
{
    foreach(var property in expression.TypeMap.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

यहां महत्वपूर्ण बात यह है कि एक बार स्थिर एपीआई हटा दिए जाने के बाद, कोड जैसे कि Mapper.FindTypeMapForअब काम नहीं करेगा, इसलिए expression.TypeMapफ़ील्ड का उपयोग ।

Comments

5.0 तक, expression.TypeMapअब उपलब्ध नहीं है। यहाँ मेरा समाधान 5.0 के लिए है

— रिचर्ड

मुझे public static IMappingExpression<TSource, TDestination> IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)टाइप मुद्दों को ठीक करने के लिए उपयोग करना था ।

— निक एम

Answer 9

आॅटोमैपर 5.0 के लिए सभी अनमैप प्रॉपर्टीज को छोड़ देना चाहिए जो आपको चाहिए

.ForAllOtherMembers (x => x.Ignore ());

आपकी प्रोफ़ाइल के अंत में।

उदाहरण के लिए:

internal class AccountInfoEntityToAccountDtoProfile : Profile
{
    public AccountInfoEntityToAccountDtoProfile()
    {
        CreateMap<AccountInfoEntity, AccountDto>()
           .ForMember(d => d.Id, e => e.MapFrom(s => s.BankAcctInfo.BankAcctFrom.AcctId))
           .ForAllOtherMembers(x=>x.Ignore());
    }
}

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

Answer 10

मैंने AutoMapper 4.2 के लिए रॉबर्ट श्रोएडर के उत्तर को अपडेट किया है। गैर-स्थैतिक मैपर कॉन्फ़िगरेशन के साथ, हम उपयोग नहीं कर सकते Mapper.GetAllTypeMaps(), लेकिन expressionआवश्यक के लिए एक संदर्भ है TypeMap:

public static IMappingExpression<TSource, TDestination> 
    IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    foreach (var property in expression.TypeMap.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

Comments

AutoMapper 5.0 में काम नहीं करता है। IMAPExpression पर .TypeMap गुण उपलब्ध नहीं है। 5. + संस्करण के लिए रिचर्ड के जवाब

— माइकल फ्रीजिम

एएम 4.2 के साथ काम करता है

— लेसज़ेक पी।

Answer 11

आप यह कैसे निर्दिष्ट करना पसंद करेंगे कि कुछ सदस्यों को अनदेखा किया जाए? क्या कोई सम्मेलन, या आधार वर्ग है, या विशेषता जिसे आप लागू करना चाहते हैं? एक बार जब आप सभी मानचित्रणों को स्पष्ट रूप से निर्दिष्ट करने के व्यवसाय में लग जाते हैं, तो मुझे यकीन नहीं होता कि आप AutoMapper से क्या मूल्य प्राप्त करेंगे।

Comments

जिमी, आपके पास गवाह के बारे में एक बिंदु है। सबसे सुरुचिपूर्ण तरीके से इसे कैसे प्राप्त किया जा सकता है, इस आधार पर इस तरह से: बेस कक्षाएं और विशेषताएँ इस स्थिति में काम नहीं करेंगी, क्योंकि लक्ष्य कक्षाएं वास्तव में मेरे नियंत्रण में नहीं हैं - वे एक्सएसडी डेटा अनुबंध से ऑटोजेनरेटेड हैं, इसलिए किसी के पास होगा प्रत्येक पीढ़ी चक्र के बाद इस कोड को मैन्युअल रूप से संपादित करने के लिए। मुझे लगता है कि समाधान एक ठोस मामले पर निर्भर करता है। हो सकता है कि विंडसर कैसल के समान धाराप्रवाह इंटरफ़ेस कंटेनर में पंजीकरण करने के लिए कौन से घटकों का चयन करता है?

— इगोर ब्रेजक

आह कि अब और अधिक समझ में आता है। यह एक दिलचस्प विशेषता है, मैं 2.1 टाइमफ्रेम में उस एक को देखूंगा।

— जिमी बोगार्ड

कैसे के बारे में सिर्फ एक विन्यास योग्य मूल्य है जहाँ आप सभी गैर-मौजूदा क्षेत्रों को "अनदेखा" कर सकते हैं।

— रिकार्डो सांचेज़

यह सवाल का जवाब नहीं है।

— user2864740

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

— नाओमी

Answer 12

यह एक पुराना सवाल है, लेकिन मुझे लगता है कि मैं किसी और के लिए अपना जवाब पोस्ट करूंगा जैसे मैं था।

मैं ConstructUsing का उपयोग करता हूं, ForAllMembers के साथ युग्मित ऑब्जेक्ट इनिशियलाइज़र जैसे उदा

    Mapper.CreateMap<Source, Target>()
        .ConstructUsing(
            f =>
                new Target
                    {
                        PropVal1 = f.PropVal1,
                        PropObj2 = Map<PropObj2Class>(f.PropObj2),
                        PropVal4 = f.PropVal4
                    })
        .ForAllMembers(a => a.Ignore());

Answer 13

कई सदस्यों को नजरअंदाज करने के बारे में केवल जानकारी यह है - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f । मुझे लगता है कि आप समान वर्गों के लिए सामान्य गुणों को अनदेखा करने के लिए ProvidingCommonBaseClassConfiguration में उपयोग की गई चाल का उपयोग कर सकते हैं।
और "बाकी की उपेक्षा" कार्यक्षमता के बारे में कोई जानकारी नहीं है। मैंने पहले कोड को देखा है और यह मुझे लगता है कि ऐसी कार्यक्षमता जोड़ने के लिए बहुत और बहुत कठिन होगा। इसके अलावा, आप कुछ विशेषताओं का उपयोग करने की कोशिश कर सकते हैं और इसके साथ गुणों को अनदेखा कर सकते हैं और सभी चिह्नित गुणों को अनदेखा करने के लिए कुछ सामान्य / सामान्य कोड जोड़ सकते हैं।

Comments

शायद एक तरीका ForAllMembers विधि का उपयोग करना होगा और अपने स्वयं के IMemberConfigurationExpression को लागू करना होगा जो उन गुणों के संपत्ति नामों से युक्त एक स्ट्रिंग प्राप्त करता है जिन्हें नजरअंदाज नहीं किया जाना चाहिए, और फिर उनमें से बाकी के माध्यम से जाएं और बीजाणु () को कॉल करें। बस एक विचार है, मुझे यकीन नहीं है कि यह काम करेगा।

— इगोर ब्रेजक

हां, यह भी काम कर सकता है, लेकिन यह विधि विशेषताओं का उपयोग करने की तुलना में अधिक मुश्किल है, लेकिन यह अधिक लचीलापन प्रदान करता है। यह अफ़सोस की बात है कि चांदी की गोली नहीं हैं :(।

— zihotki

Answer 14

मुझे पता है कि यह एक पुराना प्रश्न है, लेकिन @jmoerdyk आपके प्रश्न में:

एक प्रोफ़ाइल में जंजीर CreateMap () अभिव्यक्ति में आप इसका उपयोग कैसे करेंगे?

आप इस उत्तर का उपयोग प्रोफ़ाइल ctor के अंदर इस तरह कर सकते हैं

this.IgnoreUnmapped();
CreateMap<TSource, Tdestination>(MemberList.Destination)
.ForMember(dest => dest.SomeProp, opt => opt.MapFrom(src => src.OtherProp));

Answer 15

आप ForAllMembers का उपयोग कर सकते हैं, केवल इस तरह की आवश्यकता को अधिलेखित कर सकते हैं

public static IMappingExpression<TSource, TDest> IgnoreAll<TSource, TDest>(this IMappingExpression<TSource, TDest> expression)
        {
            expression.ForAllMembers(opt => opt.Ignore());
            return expression;
        }

सावधान रहें, यह सभी को अनदेखा कर देगा, और यदि आप कस्टम मैपिंग नहीं जोड़ेंगे, तो वे पहले से ही अनदेखा कर देंगे और काम नहीं करेंगे

इसके अलावा, मैं कहना चाहता हूं, अगर आपके पास ऑटोपापर के लिए यूनिट टेस्ट है। और आप परीक्षण करते हैं कि सभी गुणों वाले सभी मॉडल सही ढंग से मैप किए गए हैं, इसलिए आपको ऐसी एक्सटेंशन विधि का उपयोग नहीं करना चाहिए

आपको उपेक्षा से स्पष्ट रूप से लिखना चाहिए

Answer 16

गंतव्य प्रकार में मौजूद गुणों को अनदेखा करने के लिए वर्तमान (संस्करण 9) समाधान एक फ़्लिप किए गए मैपिंग और उलटफेर बनाने के लिए है:

var config = new MapperConfiguration(cfg => {
  cfg.CreateMap<TheActualDestinationType, TheActualSourceType>().ReverseMap();
});

Answer 17

3.3.1 के संस्करण में आप बस IgnoreAllPropertiesWithAnInaccessibleSetter()या IgnoreAllSourcePropertiesWithAnInaccessibleSetter()विधियों का उपयोग कर सकते हैं ।

Comments

यह मूल पोस्टर के प्रश्न के अनुसार काम नहीं करता है। ये विधियाँ केवल संरक्षित या निजी गुणों को अनदेखा करती हैं, न कि ऐसे गुण जो स्रोत से गायब हैं लेकिन गंतव्य प्रकार में मौजूद हैं।

— दान