कैसे स्रोत AutoMapper

Question

के साथ एक चपटा संपत्ति के नाम पर आधारित संपत्ति मैं AutoMapper उपयोग कर रहा हूँ लगता है और मैं इसे मैप किया (चपटा) गंतव्य संपत्ति के नाम पर आधारित एक स्रोत संपत्ति वापस ट्रेस करने के लिए करना चाहते हैं।

इसका कारण यह है मेरी MVC नियंत्रक एक मैप की गई संपत्ति है कि यह प्रयोजनों छँटाई के लिए है कि एक सेवा कॉल करने के लिए प्रदान करने की जरूरत के नाम पर है। सेवा को उस संपत्ति के नाम को जानने की आवश्यकता है जो मैपिंग से उत्पन्न होता है (और नियंत्रक इसे नहीं जानता है) ताकि वास्तव में डेटा को संग्रहीत करने वाले भंडार को उचित कॉल करने के लिए किया जा सके।

उदाहरण के लिए

: [Destination.AddressZipCode]

फिर वापस करने के लिए

ट्रेस "AddressZipCode" करने के लिए

[Source.Address.ZipCode] नक्शे [Source.Address .ZipCode]

क्या यह कुछ वें है ऑटोमैपर पर मेरे लिए क्या कर सकता है या क्या मुझे ऑटोमैपर के मैपिंग डेटा में खुदाई करने का सहारा लेना है?

अद्यतन

जिमी Bogard मुझसे कहा था कि यह संभव होना चाहिए लेकिन एक स्पष्ट तरीके से नहीं। इसे टाइप मैप लोड करने और इसके माध्यम से जाने की आवश्यकता है। मैंने इसे संक्षेप में देखा है, लेकिन ऐसा लगता है कि रिवर्स मैपिंग करने के लिए आवश्यक संपत्ति मैपिंग जानकारी प्राप्त करने के लिए मुझे आंतरिक प्रकारों तक पहुंच की आवश्यकता है।

अद्यतन 2

मैं कुछ और जानकारी प्रदान करने के लिए तय कर लिया है।

• एक AutoMapper.Internal.PropertyGetter कि पता हो जाता है:

  जब मैं प्रकार नक्शा लोड, मैं अंतर्निहित ज़िपकोड मानचित्रण के लिए इसमें दो स्रोत मान रिसोल्वर देखते हैं कि लगता है।

• AutoMapper.Internal.PropertyGetter जो ज़िपकोड प्राप्त करता है।

जब मैं एक स्पष्ट मानचित्रण (है कि एक लैम्ब्डा अभिव्यक्ति निर्दिष्ट है) है, मैं कोई स्रोत मूल्य समाधानकर्ता लेकिन एक कस्टम समाधानकर्ता लगता है:

• एक AutoMapper.DelegateBasedResolver<Company,string> मुझे लगता है कि मेरी स्पष्ट मानचित्रण लैम्ब्डा अभिव्यक्ति रखती है।

दुर्भाग्य से इन रिसोल्वर आंतरिक हैं तो मैं केवल उन्हें प्रतिबिंब (जो मैं वास्तव में क्या करने के लिए नहीं करना चाहते हैं) के माध्यम से या AutoMapper स्रोत कोड को बदलने के द्वारा पहुँच सकते हैं।

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

Answer 1

के लिए समय से किया जा रहा है, मैं एक सहायक वर्ग है कि एक concatenated संपत्ति श्रृंखला। बेशक से होने वाले संपत्ति श्रृंखला निर्धारित कर सकते हैं लिखा है, यह जब AutoMapper बात इस तरह का करने के लिए एक सुविधा हो जाता है अप्रचलित हो जाएगा।

using System.Globalization; 
using System.Reflection; 

/// <summary> 
///  Resolves concatenated property names back to their originating properties. 
/// </summary> 
/// <remarks> 
///  An example of a concatenated property name is "ProductNameLength" where the originating 
///  property would be "Product.Name.Length". 
/// </remarks> 
public static class ConcatenatedPropertyNameResolver 
{ 
    private static readonly object mappingCacheLock = new object(); 
    private static readonly Dictionary<MappingCacheKey, string> mappingCache = new Dictionary<MappingCacheKey, string>(); 

    /// <summary> 
    ///  Returns the nested name of the property the specified concatenated property 
    ///  originates from. 
    /// </summary> 
    /// <param name="concatenatedPropertyName">The concatenated property name.</param> 
    /// <typeparam name="TSource">The mapping source type.</typeparam> 
    /// <typeparam name="TDestination">The mapping destination type.</typeparam> 
    /// <returns> 
    ///  The nested name of the originating property where each level is separated by a dot. 
    /// </returns> 
    public static string GetOriginatingPropertyName<TSource, TDestination>(string concatenatedPropertyName) 
    { 
     if (concatenatedPropertyName == null) 
     { 
      throw new ArgumentNullException("concatenatedPropertyName"); 
     } 
     else if (concatenatedPropertyName.Length == 0) 
     { 
      throw new ArgumentException("Cannot be empty.", "concatenatedPropertyName"); 
     } 

     lock (mappingCacheLock) 
     { 
      MappingCacheKey key = new MappingCacheKey(typeof(TSource), typeof(TDestination), concatenatedPropertyName); 

      if (!mappingCache.ContainsKey(key)) 
      { 
       BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public; 

       List<string> result = new List<string>(); 
       Type type = typeof(TSource); 

       while (concatenatedPropertyName.Length > 0) 
       { 
        IEnumerable<PropertyInfo> properties = type.GetProperties(bindingFlags).Where(
         n => concatenatedPropertyName.StartsWith(n.Name)).ToList(); 

        if (properties.Count() == 1) 
        { 
         string match = properties.First().Name; 
         result.Add(match); 
         concatenatedPropertyName = concatenatedPropertyName.Substring(match.Length); 
         type = type.GetProperty(match, bindingFlags).PropertyType; 
        } 
        else if (properties.Any()) 
        { 
         throw new InvalidOperationException(
          string.Format(
           CultureInfo.InvariantCulture, 
           "Ambiguous properties found for {0} on type {1}: {2}.", 
           concatenatedPropertyName, 
           typeof(TSource).FullName, 
           string.Join(", ", properties.Select(n => n.Name)))); 
        } 
        else 
        { 
         throw new InvalidOperationException(
          string.Format(
           CultureInfo.InvariantCulture, 
           "No matching property found for {0} on type {1}.", 
           concatenatedPropertyName, 
           typeof(TSource).FullName)); 
        } 
       } 

       mappingCache.Add(key, string.Join(".", result)); 
      } 

      return mappingCache[key]; 
     } 
    } 

    /// <summary> 
    ///  A mapping cache key. 
    /// </summary> 
    private struct MappingCacheKey 
    { 
     /// <summary> 
     ///  The source type. 
     /// </summary> 
     public Type SourceType; 

     /// <summary> 
     ///  The destination type the source type maps to. 
     /// </summary> 
     public Type DestinationType; 

     /// <summary> 
     ///  The name of the mapped property. 
     /// </summary> 
     public string MappedPropertyName; 

     /// <summary> 
     ///  Initializes a new instance of the <see cref="MappingCacheKey"/> class. 
     /// </summary> 
     /// <param name="sourceType">The source type.</param> 
     /// <param name="destinationType">The destination type the source type maps to.</param> 
     /// <param name="mappedPropertyName">The name of the mapped property.</param> 
     public MappingCacheKey(Type sourceType, Type destinationType, string mappedPropertyName) 
     { 
      SourceType = sourceType; 
      DestinationType = destinationType; 
      MappedPropertyName = mappedPropertyName; 
     } 
    } 
} 

यहाँ एक उपयोग उदाहरण है :

class TestEntity 
{ 
    public Node Root {get; set;} 
} 

class Node 
{ 
    public string Leaf {get; set;} 
} 

class TestFlattenedEntity 
{ 
    public string RootLeaf {get; set;} 
} 

string result = ConcatenatedPropertyNameResolver.GetOriginatingPropertyName<TestEntity, TestFlattenedEntity>("RootLeaf"); 

Assert.AreEqual("Root.Leaf", result); 

Answer 2

मैं AutoMapper के साथ एक समान की जरूरत में फंस गयी।यहां वह समाधान है जिसके साथ मैं कर सकता हूं। मैंने केवल बहुत ही सरल मैपिंग के खिलाफ इसका परीक्षण किया है। मुख्य रूप से केवल गुणों के साथ एक से दूसरे वर्ग इस्तेमाल किया जा रहा (मूल रूप से Mapper.CreateMap के डिफ़ॉल्ट व्यवहार को। मैं केवल एक मानचित्रण है कि वहाँ संभालने हूँ, तो मैं सबसे पहले संग्रह से अधिक पुनरावृत्ति के बजाय का उपयोग करें।

private MemberInfo getSource(Type destinationType, string destinationPropertyname) 
    { 
     TypeMap map = Mapper.GetAllTypeMaps().Where(m => m.DestinationType.Equals(destinationType)).First(); 

     IEnumerable<PropertyMap> properties = map.GetPropertyMaps().Where(p => p.DestinationProperty.Name.Equals(destinationPropertyname, StringComparison.CurrentCultureIgnoreCase)); 

     PropertyMap sourceProperty = properties.First(); 

     IMemberGetter mg = sourceProperty.GetSourceValueResolvers().Cast<IMemberGetter>().First(); 

     return mg.MemberInfo; 
    } 

Answer 3

मैं एक ही समस्या को देख रहा हूं, और निम्न कोड स्निपेट के साथ आया था। यह ऑटोमैपर से अप्रत्याशित संपत्ति श्रृंखला के साथ आता है। मुझे sgriffinusa के समाधान से कुछ प्रेरणा मिली।

using System.Linq; 
using System.Reflection; 
using AutoMapper; 

public static class TypeMapExtensions 
{ 
    public static MemberInfo[] TryGetSourceProperties(this TypeMap @this, string propertyName) 
    { 
     if (@this != null) 
     { 
      var propertyMap = @this.GetPropertyMaps() 
       .Where(p => p.DestinationProperty.Name == propertyName).FirstOrDefault(); 

      if (propertyMap != null) 
      { 
       var sourceProperties = propertyMap.GetSourceValueResolvers().OfType<IMemberGetter>(); 
       if (sourceProperties.Any()) 
        return sourceProperties.Select(x => x.MemberInfo).ToArray(); 
      } 
     } 
     return null; 
    } 

    /// <summary> 
    /// Trys to retrieve a source property name, given a destination property name. Only handles simple property mappings, and flattened properties. 
    /// </summary> 
    public static string TryGetSourcePropertyName(this TypeMap @this, string propertyName) 
    { 
     var members = TryGetSourceProperties(@this, propertyName); 
     return (members == null) ? null : string.Join(".", members.Select(x => x.Name).ToArray()); 
    } 
} 

और आप का उपयोग कर वांछित TypeMap मिलती है:

Mapper.FindTypeMapFor<TSource, TDestination>(); 

Answer 4

ValueInjecter साथ तुम कर सकते हो:

var trails = TrailFinder.GetTrails(flatPropertyName, target.GetType().GetInfos(), t => true); 

लक्ष्य unflat वस्तु है (हम PropertyInfo के संग्रह में उत्तीर्ण होना)

ट्रेल्स तारों की एक सूची होगी

var result = string.join(".",trails.ToArray());