ईएफ इकाइयों के लिए EntityKey मानों को मैप करने के लिए ऑटोमैपर के ValueResolver का उपयोग करने का एक सामान्य तरीका है?

Question

यह सुनिश्चित नहीं है कि शीर्षक समझ में आता है, लेकिन यह है कि मैं क्या कर रहा हूं। मैं अपने डीटीओ ऑब्जेक्ट्स और इसके विपरीत में अपनी इकाई फ्रेमवर्क इकाइयों को मैप करने के लिए ऑटोमैपर का उपयोग कर रहा हूं। मुद्दा तब आता है जब मैं डीटीओ डेटा को ईएफ इकाई में मैप करने का प्रयास करता हूं। EntityKey के लिए संपत्ति मानचित्रण की कोई संपत्ति नहीं है। इसे ठीक करने के लिए, मैं निम्नलिखित की तरह कुछ कार्य करें:

 Mapper.CreateMap<VideoDTO, Video>() 
      .ForMember(dest => dest.EntityKey, opt => 
opt.ResolveUsing<VideoEntityKeyResolver>()); 

VideoEntityKeyResolver वर्ग लगता है: अगर वहाँ जहाँ मैं 1 वर्ग हो सकता था ऐसा करने का एक अधिक सामान्य तरीका था

public class VideoEntityKeyResolver : ValueResolver<VideoDTO, EntityKey> 
{ 
    protected override EntityKey ResolveCore(VideoDTO source) 
    { 
     EntityKey key = new EntityKey("EntityFrameworkTestingEntities.Videos", 
      "VideoId", source.VideoId); 
     return key; 
    } 
} 

मैं सोच रहा था एक निर्माता के साथ जो एक निर्माता में इकाई सेट नाम, मुख्य संपत्ति का नाम, और कुंजी मान लेता है।

मैंने अपने डीटीओ ऑब्जेक्ट्स में केवल एंटीटीकी संपत्ति जोड़ने के बारे में सोचा है जो डीटीओ ऑब्जेक्ट्स बनाने के पूरे बिंदु के रूप में धाराओं को पार करने की तरह लगता है क्योंकि मेरे बाकी हिस्सों में मेरी डेटा परत से टाई गंभीर थी ।

एक पूरी तरह से असंबंधित नोट पर (यदि आवश्यक हो तो मैं एक नया प्रश्न बना सकता हूं), जहां ऑटोमैपर का उपयोग करते समय मुझे अपने मैपिंग को परिभाषित करने की ज़रूरत है? वर्तमान में मैं इसे अपने संदर्भ ऑब्जेक्ट (जो मेरा ईएफ रिपोजिटरी ऑब्जेक्ट है) के निर्माता में कर रहा हूं, लेकिन मेरा मानना ​​है कि यह महंगा है और सही नहीं है, हालांकि, यह काम करता है।

Answer 1

मैं अब तक इस परीक्षण करने के लिए के रूप में नहीं गए, लेकिन निम्नलिखित काम करना चाहिए:

public class EntityKeyResolver<T, TProperty> : ValueResolver<T, EntityKey> where T : class 
{ 
    private Expression<Func<T, TProperty>> _propertyExpression; 
    private string _qualifiedEntitySetName; 
    private string _keyName; 

    public EntityKeyResolver(string qualifiedEntitySetName, string keyName, Expression<Func<T, TProperty>> propertyExpression) 
    { 
     _qualifiedEntitySetName = qualifiedEntitySetName; 
     _keyName = keyName; 
     _propertyExpression = propertyExpression; 
    } 

    protected override EntityKey ResolveCore(T source) 
    { 
     return new EntityKey(_qualifiedEntitySetName, _keyName, ExpressionHelper.GetValue(_propertyExpression)); 
    } 
} 

ExpressionHelper एक स्थिर वर्ग है कि मैं मामलों की एक किस्म में भाव मूल्यांकन करने में मदद करने के लिए इस्तेमाल करते हैं। GetValue विधि इस प्रकार है:

internal static TProperty GetValue<T, TProperty>(T obj, Expression<Func<T, TProperty>> expression) where T : class 
{ 
    if (obj == null) 
    { 
     return default(TProperty); 
    } 

    Func<T, TProperty> func = expression.Compile(); 

    return func(obj); 
} 

इस प्रकार है तब आप अपने कोड बदल जाएगा (यह मानते हुए VIDEOID एक GUID है):

Mapper.CreateMap<VideoDTO, Video>()   
      .ForMember(dest => dest.EntityKey, opt => opt.ResolveUsing(new EntityKeyResolver<VideoDTO, Guid>("EntityFrameworkTestingEntities.Videos", "VideoId", v => v.VideoId))); 

शायद थोड़ा और वर्बोज़ से आप चाहते थे। सामान्य रिसोल्वर के लिए एक वैकल्पिक MapFrom उपयोग करने के लिए इकाई कुंजी मैप करने के लिए होगा (वे के बारे में समान रूप से अत्यधिक शब्द हैं):

Mapper.CreateMap<VideoDTO, Video>()   
       .ForMember(dest => dest.EntityKey, opt => opt.MapFrom(src => new EntityKey("EntityFrameworkTestingEntities.Videos", "VideoId", src.VideoId))); 

अपने अन्य प्रश्न के रूप में, मैं एक स्थिर वर्ग बनाने की आदत में मिल गया है कि मेरे मैप्स को शुरू करता है और मैपिंग्स बनने के लिए एक बूलियन सेट करता है क्योंकि आपको केवल ऐपडोमेन के बाद इसे कॉल करने की आवश्यकता होती है। फिर, मेरे भंडार के निर्माता में, मैं बस MapInitializer.EnsureMaps();