Esempio n. 1
0
        public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList <MemberInfo> resolvers, IMemberConfiguration parent)
        {
            string[] matches = DestinationMemberNamingConvention.SplittingExpression
                               .Matches(nameToSearch)
                               .Cast <Match>()
                               .Select(m => SourceMemberNamingConvention.ReplaceValue(m))
                               .ToArray();
            MemberInfo matchingMemberInfo = null;

            for (int i = 1; i <= matches.Length; i++)
            {
                NameSnippet snippet = CreateNameSnippet(matches, i);

                matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, snippet.First);

                if (matchingMemberInfo != null)
                {
                    resolvers.AddLast(matchingMemberInfo);

                    var details    = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
                    var foundMatch = parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, snippet.Second, resolvers);

                    if (!foundMatch)
                    {
                        resolvers.RemoveLast();
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return(matchingMemberInfo != null);
        }
Esempio n. 2
0
        private bool MapDestinationPropertyToSource(LinkedList <MemberInfo> resolvers, TypeInfo sourceType,
                                                    string nameToSearch, IMappingOptions mappingOptions)
        {
            if (string.IsNullOrEmpty(nameToSearch))
            {
                return(true);
            }

            var sourceProperties            = sourceType.PublicReadAccessors;
            var sourceNoArgMethods          = sourceType.PublicNoArgMethods;
            var sourceNoArgExtensionMethods = sourceType.PublicNoArgExtensionMethods;

            MemberInfo resolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods,
                                                 nameToSearch, mappingOptions);

            bool foundMatch = resolver != null;

            if (foundMatch)
            {
                resolvers.AddLast(resolver);
            }
            else
            {
                string[] matches = mappingOptions.DestinationMemberNamingConvention.SplittingExpression
                                   .Matches(nameToSearch)
                                   .Cast <Match>()
                                   .Select(m => m.Value)
                                   .ToArray();

                for (int i = 1; (i <= matches.Length) && (!foundMatch); i++)
                {
                    NameSnippet snippet = CreateNameSnippet(matches, i, mappingOptions);

                    var valueResolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods,
                                                       snippet.First,
                                                       mappingOptions);

                    if (valueResolver != null)
                    {
                        resolvers.AddLast(valueResolver);

                        foundMatch = MapDestinationPropertyToSource(resolvers,
                                                                    GetTypeInfo(valueResolver.GetMemberType(), mappingOptions),
                                                                    snippet.Second, mappingOptions);

                        if (!foundMatch)
                        {
                            resolvers.RemoveLast();
                        }
                    }
                }
            }

            return(foundMatch);
        }