linq – 将表达式树从一种类型转换为另一种具有复杂映射的类型

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Id { get; set; }
    public DateTime? BirthDate { get; set; }
    public int CustomerTypeId { get; set; }
}

public class CustomerModel
{
    ...
    public bool HasEvenId { get; set; }
}

我想要转换的可能表达式的示例是：

Expression<Func<CustomerModel,bool>> from = model => model.HasEvenId;
Expression<Func<Customer,bool>> to = entity => ((entity.Id % 2) == 0);

问题是我必须通过ASP.NET WebAPI公开OData端点,但是我需要先对实体进行一些操作,因此需要一个模型类,需要根据模型转换表达式我可以在基于实体的表达式中接收OData查询,我将用它来查询EF4.

这是我到目前为止的地方：

private static readonly Dictionary<Expression,Expression> Mappings = GetMappings();

private static Dictionary<Expression,Expression> GetMappings()
{
    var mappings = new Dictionary<Expression,Expression>();

    var mapping = GetMappingFor((CustomerModel model) => model.HasEvenId,(Customer customer) => (customer.Id%2) == 0);
    mappings.Add(mapping.Item1,mapping.Item2);

    return mappings;
}

private static Tuple<Expression,Expression> GetMappingFor<TFrom,TTo,TValue>(Expression<Func<TFrom,TValue>> fromExpression,Expression<Func<TTo,TValue>> toExpression)
{
    MemberExpression fromMemberExpression = (MemberExpression) fromExpression.Body;
    return Tuple.Create<Expression,Expression>(fromMemberExpression,toExpression);
}

public static Expression<Func<TTo,bool>> Translate<TFrom,TTo>(Expression<Func<TFrom,bool>> expression,Dictionary<Expression,Expression> mappings = null)
{
    if (expression == null)
        return null;

    string parameterName = expression.Parameters[0].Name;

    parameterName = string.IsNullOrWhiteSpace(parameterName) ? "p" : parameterName;

    var param = Expression.Parameter(typeof(TTo),parameterName);
    var subst = new Dictionary<Expression,Expression> { { expression.Parameters[0],param } };
    ParameterChangeVisitor parameterChange = new ParameterChangeVisitor(parameterName);
    if (mappings != null)
        foreach (var mapp in mappings)
            subst.Add(mapp.Key,parameterChange.Visit(mapp.Value));

    var visitor = new TypeChangeVisitor(typeof(TFrom),typeof(TTo),subst);
    return Expression.Lambda<Func<TTo,bool>>(visitor.Visit(expression.Body),param);
}

public IQueryable<CustomerModel> Get()
{
    var filterExtractor = new ODataFilterExtractor<CustomerModel>();
    Expression<Func<CustomerModel,bool>> expression = filterExtractor.Extract(Request);
    Expression<Func<Customer,bool>> translatedExpression = Translate<CustomerModel,Customer>(expression,Mappings);

    IQueryable<Customer> query = _context.Customers;

    if (translatedExpression != null)
        query = query.Where(translatedExpression);

    var finalQuery = from item in query.AsEnumerable() 
                     select new CustomerModel()
                        {
                            FirstName = item.FirstName,LastName = item.LastName,Id = item.Id,BirthDate = item.BirthDate,CustomerTypeId = item.CustomerTypeId,HasEvenId = (item.Id % 2 ) == 0
                        };

    return finalQuery.AsQueryable();
}

哪里：

> ODataFilterExtractor是一个从我们收到的RequestMessage中提取$filter表达式的类;
> ParameterChangeVisitor只是将所有的ParameterExpression更改为一个新的,其中提供的字符串作为参数名称;

另外,我以这种方式更改了上面链接的答案的VisitMember方法：

protected override Expression VisitMember(MemberExpression node)
{
    // if we see x.Name on the old type,substitute for new type
    if (node.Member.DeclaringType == _from)
    {
        MemberInfo toMember = _to.GetMember(node.Member.Name,node.Member.MemberType,BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault();
        if (toMember != null)
        {
            return Expression.MakeMemberAccess(Visit(node.Expression),toMember);
        }
        else
        {
            if (_substitutions.Select(kvp => kvp.Key).OfType<MemberExpression>().Any(me => me.Member.Equals(node.Member)))
            {
                MemberExpression key = _substitutions.Select(kvp => kvp.Key).OfType<MemberExpression>().Single(me => me.Member.Equals(node.Member));
                Expression value = _substitutions[key];

                // What to return here?
                return Expression.Invoke(value);
            }
        }
    }
    return base.VisitMember(node);
}

谢谢你的帮助.