Fix issue108

[4E-69-63-6B-20-42-6F-73]

Fix for issue #108

[BlaiseD]

Sorry I misunderstood the issue. For some reason I thought the problem was with mapping anonymous types.

We don't want to make exceptions for specific methods like Select. The solution would be to map the NewExpression and the MemberInitExpression. e.g. In ExpressionMapper.cs

            protected override Expression VisitNew(NewExpression node)
            {
                if (node.Type == _oldParam.Type)
                    return Expression.New(_newParam.Type);

                return base.VisitNew(node);
            }

            protected override Expression VisitMemberInit(MemberInitExpression node)
            {
                if (node.Type == _oldParam.Type)
                {
                    var typeMap = _configurationProvider.ResolveTypeMap(sourceType: _newParam.Type, destinationType: node.Type);

                    IEnumerable<MemberBinding> bindings = node.Bindings.Aggregate(new List<MemberBinding>(), (list, binding) =>
                    {
                        var propertyMap = typeMap.PropertyMaps.SingleOrDefault(item => item.DestinationName == binding.Member.Name);
                        if (propertyMap == null)
                            return list;

                        var sourceMember = GetSourceMember(propertyMap);
                        if (sourceMember == null)
                            return list;

                        Expression bindingExpression = ((MemberAssignment)binding).Expression;
                        list.Add
                        (
                            DoBind
                            (
                                sourceMember,
                                bindingExpression,
                                this.Visit(bindingExpression)
                            )
                        );

                        return list;
                    });

                    return Expression.MemberInit(Expression.New(_newParam.Type), bindings);
                }

                return base.VisitMemberInit(node);
            }

            private MemberBinding DoBind(MemberInfo sourceMember, Expression initial, Expression mapped)
            {
                mapped = mapped.ConvertTypeIfNecessary(sourceMember.GetMemberType());
                return Expression.Bind(sourceMember, mapped);
            }

            private MemberInfo GetSourceMember(PropertyMap propertyMap)
                => propertyMap.CustomMapExpression != null
                    ? propertyMap.CustomMapExpression.GetMemberExpression()?.Member
                    : propertyMap.SourceMember;

This sample works for your test case if I remove the lines you added. It only covers the top level types though. From looking at the code in this class it recursively creates new visitors to handle child property maps.

If you're interested then maybe it's best to close this one and try the other approach.

[4E-69-63-6B-20-42-6F-73]

Okay. I see why the other approach is better, so I will close this one and try again