Automapper 自动制版机……”；CreateMapExpression"；不'；不支持为“的Linq.Expression创建映射”；“枚举”；从不同的命名空间中键入

根据我使用Automapper映射Linq.Expression的测试，不支持在不同的名称空间中使用“Enum”。 请看下面我的样品

namespace TestNamespace1
{

    public enum EnumTypes
    {
        EnumType01,
        EnumType02
    }
}

namespace TestNamespace2
{
    public enum EnumTypes
    {
        EnumType01,
        EnumType02
    }
}

namespace MappingTest
{
    class A
    {
        public TestNamespace1.EnumTypes EnumType { get; set; } 
    }

    class B
    {
        public TestNamespace2.EnumTypes EnumType { get; set; }
    }

   class TestMapping
    {
    static void Main()
        {
            var bDataSource = new List<B> { new B { EnumType = **TestNamespace2**.EnumTypes.EnumType01 } };
            Mapper.CreateMap<A, B>();
            Mapper.CreateMap<B, A>();
            Expression<Func<A, bool>> expressionA = x => x.EnumType == TestNamespace1.EnumTypes.EnumType01;
            var expressionB = GetMappedSelectorForAB(expressionA);
            var result = bDataSource.AsQueryable().Where(expressionB);
            foreach (B b in result)
            {
                Console.WriteLine("Matching B: {0}", b.EnumType.ToString());
            }
    }

        static Expression<Func<B, bool>> GetMappedSelectorForAB(Expression<Func<A, bool>> selector)
        {
            Expression<Func<B, A>> mapper = AutoMapper.QueryableExtensions.Extensions.CreateMapExpression<B, A>(Mapper.Engine);
            Expression<Func<B, bool>> mappedSelector = selector.Compose(mapper);
            return mappedSelector;
        }
    }

public static class FunctionCompositionExtensions
{
    public static Expression<Func<X, Y>> Compose<X, Y, Z>(this Expression<Func<Z, Y>> outer, Expression<Func<X, Z>> inner)
    {
        return Expression.Lambda<Func<X, Y>>(
            ParameterReplacer.Replace(outer.Body, outer.Parameters[0], inner.Body),
            inner.Parameters[0]);
    }
}

class ParameterReplacer : ExpressionVisitor
{
    private ParameterExpression _parameter;
    private Expression _replacement;

    private ParameterReplacer(ParameterExpression parameter, Expression replacement)
    {
        _parameter = parameter;
        _replacement = replacement;
    }

    public static Expression Replace(Expression expression, ParameterExpression parameter, Expression replacement)
    {
        return new ParameterReplacer(parameter, replacement).Visit(expression);
    }

    protected override Expression VisitParameter(ParameterExpression parameter)
    {
        if (parameter == _parameter)
        {
            return _replacement;
        }
        return base.VisitParameter(parameter);
    }
}
}

有没有办法实施它？我们知道目标和源对象可能有自己的名称空间[DTO]

class A
{
    public TestNamespace1.EnumTypes EnumType { get; set; } 
}

class B
{
    public TestNamespace1.EnumTypes EnumType { get; set; }
}