c# - Automapper के साथ एक संपत्ति मैपिंग अनदेखा करें




model viewmodel object-object-mapping (8)

मैं ऑटोमैपर का उपयोग कर रहा हूं और मेरे पास निम्न परिदृश्य है: क्लास ऑर्डरमोडेल में 'ProductName' नामक एक संपत्ति है जो डेटाबेस में नहीं है। तो जब मैं मैपिंग करने की कोशिश करता हूं:

Mapper.CreateMap<OrderModel, Orders>(); 

यह एक अपवाद उत्पन्न करता है:

"Project.ViewModels.OrderModel पर निम्नलिखित 1 गुण मैप नहीं किए गए हैं: 'ProductName'

मैंने अनुमान के लिए ऑटोमैपर की विकी पर विपरीत मामला पढ़ा है (अतिरिक्त विशेषता गंतव्य पर है, न कि स्रोत में जो वास्तव में मेरा मामला है)

मैं इस संपत्ति के मानचित्रण को बनाने के लिए ऑटोमैपर से कैसे बच सकता हूं?


Answers

हैलो सब कृपया इसका इस्तेमाल करें यह ठीक काम कर रहा है ... ऑटो मैपर के लिए एकाधिक का उपयोग करें। सी # में मेम्बर

        if (promotionCode.Any())
        {
            Mapper.Reset();
            Mapper.CreateMap<PromotionCode, PromotionCodeEntity>().ForMember(d => d.serverTime, o => o.MapFrom(s => s.promotionCodeId == null ? "date" : String.Format("{0:dd/MM/yyyy h:mm:ss tt}", DateTime.UtcNow.AddHours(7.0))))
                .ForMember(d => d.day, p => p.MapFrom(s => s.code != "" ? LeftTime(Convert.ToInt32(s.quantity), Convert.ToString(s.expiryDate), Convert.ToString(DateTime.UtcNow.AddHours(7.0))) : "Day"))
                .ForMember(d => d.subCategoryname, o => o.MapFrom(s => s.subCategoryId == 0 ? "" : Convert.ToString(subCategory.Where(z => z.subCategoryId.Equals(s.subCategoryId)).FirstOrDefault().subCategoryName)))
                .ForMember(d => d.optionalCategoryName, o => o.MapFrom(s => s.optCategoryId == 0 ? "" : Convert.ToString(optionalCategory.Where(z => z.optCategoryId.Equals(s.optCategoryId)).FirstOrDefault().optCategoryName)))
                .ForMember(d => d.logoImg, o => o.MapFrom(s => s.vendorId == 0 ? "" : Convert.ToString(vendorImg.Where(z => z.vendorId.Equals(s.vendorId)).FirstOrDefault().logoImg)))
                .ForMember(d => d.expiryDate, o => o.MapFrom(s => s.expiryDate == null ? "" : String.Format("{0:dd/MM/yyyy h:mm:ss tt}", s.expiryDate))); 
            var userPromotionModel = Mapper.Map<List<PromotionCode>, List<PromotionCodeEntity>>(promotionCode);
            return userPromotionModel;
        }
        return null;

मैंने स्टीव रुक्ट्स द्वारा जोड़े गए एक विस्तार की सराहना की, इसलिए मैंने अपने उदाहरण के आधार पर एक और विस्तार विधि जोड़ने का फैसला किया। उम्मीद है कि यह किसी की मदद करेगा:

    public static IMappingExpression<TSource, TDestination> Map<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> map,
        Expression<Func<TSource, object>> src,
        Expression<Func<TDestination, object>> dst)
    {
        map.ForMember(dst, opt => opt.MapFrom(src));
        return map;
    }

उपयोग:

    Mapper.Initialize(cfg => cfg.CreateMap<UserModel, UserDto>()
        .Map(src => src.FirstName + " " + src.LastName, dst => dst.UserName));

मैं शायद एक पूर्णतावादी का थोड़ा सा हूँ; मुझे वास्तव में ForMember (..., x => x.Ignore ()) वाक्यविन्यास पसंद नहीं है। यह एक छोटी सी चीज है, लेकिन यह मेरे लिए मायने रखती है। मैंने इसे विस्तारित करने के लिए इस विस्तार विधि को लिखा है:

public static IMappingExpression<TSource, TDestination> Ignore<TSource, TDestination>(
    this IMappingExpression<TSource, TDestination> map,
    Expression<Func<TDestination, object>> selector)
{
    map.ForMember(selector, config => config.Ignore());
    return map;
}

इसका उपयोग इस प्रकार किया जा सकता है:

Mapper.CreateMap<JsonRecord, DatabaseRecord>()
        .Ignore(record => record.Field)
        .Ignore(record => record.AnotherField)
        .Ignore(record => record.Etc);

आप इसे params साथ काम करने के लिए भी लिख सकते हैं, लेकिन मुझे लैम्ब्स के भार के साथ एक विधि की तरह पसंद नहीं है।


तुम यह केर सकते हो:

conf.CreateMap<SourceType, DestinationType>()
   .ForSourceMember(x => x.SourceProperty, y => y.Ignore());

एक मॉडल मॉडल पर एक दृश्य मॉडल को मैप करते समय, गंतव्य सदस्य सूची की बजाय स्रोत सदस्य सूची को सत्यापित करने के लिए यह बहुत साफ हो सकता है

Mapper.CreateMap<OrderModel, Orders>(MemberList.Source); 

अब मेरी मैपिंग सत्यापन विफल नहीं होती है, किसी अन्य Ignore() आवश्यकता होती है, हर बार जब मैं अपनी डोमेन कक्षा में कोई संपत्ति जोड़ता हूं।



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

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

टिप के लिए जेनसर के लिए धन्यवाद :)

स्रोत: http://cangencer.wordpress.com/2011/06/08/auto-ignore-non-existing-properties-with-automapper/


मेरा पहला सवाल होगा, क्या आपकी आवश्यकताओं को निर्देश दिया गया है कि एक निश्चित लंबाई स्ट्रिंग की आवश्यकता है? यदि ऐसा है तो एक char [] वास्तव में वह हो सकता है जिसका आप उपयोग करना चाहते हैं।

.NET ढांचा सीधे सी-स्टाइल स्ट्रिंग्स (चार सरणी) का उपयोग नहीं करता है, बल्कि इसके बजाय अपरिवर्तनीय संदर्भों से स्ट्रिंग का प्रतिनिधित्व करता है। जब एक स्ट्रिंग को संशोधित या संशोधित किया जाता है, तो आप वास्तव में स्मृति में एक नई स्ट्रिंग ऑब्जेक्ट बना रहे हैं। यह मंच की वांछित विशेषता है, लेकिन जिस पर जादुई रूप से आकार बदलने वाले तारों की अपेक्षा के रूप में विचार की आवश्यकता होती है, वह कुछ अवांछित दुष्प्रभावों का कारण बन सकती है।

अपने प्रश्न पर वापस जाएं। "सी # स्ट्रक्चर में तारों का प्रबंधन कैसे करता है?"

मैं जो देखता हूं उससे इस प्रश्न की व्याख्या करने के दो तरीकों में से एक:

1)। मैं स्ट्रिंग्स वाले स्ट्रक्चर कैसे बना सकता हूं, और .NET Framework इस परिदृश्य में तारों का प्रबंधन कैसे करता है?

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

2)। .NET Framework स्ट्रिंग का आकार बदल सकता है यदि वे structs द्वारा प्रतिनिधित्व किए गए मान प्रकार हैं।

संक्षिप्त जवाब, यह नहीं है। ऐसा नहीं है कि .NET स्ट्रिंग के साथ कैसे काम करता है, ऊपर देखें।





c# model viewmodel automapper object-object-mapping