18

（基于电子邮件对话，现在记录用于信息共享）我在不同的层使用了两个模型：

public class TestDTO {
    public int CustomerID { get; set; }
}
//...
public class Test {
    public int CustomerID { get; set; }
}

以及就我的 DTO 层而言的 lambda：

Expression<Func<TestDTO, bool>> fc1 =
   (TestDTO c1) => c1.CustomerID <= 100 && c1.CustomerID >= 10;

如何将该 lambda（在一般情况下）转换为谈论另一个模型：

Expression<Func<Test, bool>> fc2 = {insert magic here, based on fc1}

（显然，我们追求相同的测试条件，但使用Test类型）

?

4

2 回答 2

20

为此，您必须完全重建表达式树；参数将需要重新映射，并且现在与不同类型对话的所有成员访问都需要重新应用。幸运的是，这门课让很多事情变得更容易了ExpressionVisitor。例如（在一般情况下做这一切，而不仅仅是Func<T,bool>谓词用法）：

class TypeConversionVisitor : ExpressionVisitor
{
    private readonly Dictionary<Expression, Expression> parameterMap;

    public TypeConversionVisitor(
        Dictionary<Expression, Expression> parameterMap)
    {
        this.parameterMap = parameterMap;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        // re-map the parameter
        Expression found;
        if(!parameterMap.TryGetValue(node, out found))
            found = base.VisitParameter(node);
        return found;
    }
    protected override Expression VisitMember(MemberExpression node)
    {
        // re-perform any member-binding
        var expr = Visit(node.Expression);
        if (expr.Type != node.Type)
        {
            MemberInfo newMember = expr.Type.GetMember(node.Member.Name)
                                       .Single();
            return Expression.MakeMemberAccess(expr, newMember);
        }
        return base.VisitMember(node);
    }
}

在这里，我们传入一个参数字典来重新映射，将其应用到VisitParameter. 我们还会在 inVisitMember中检查我们是否已经切换了类型（如果Visit涉及 aParameterExpression或 another MemberExpression，随时可能发生这种情况）：如果有，我们将尝试找到另一个同名的成员。

接下来，我们需要一个通用的 lambda 转换重写器方法：

// allows extension to other signatures later...
private static Expression<TTo> ConvertImpl<TFrom, TTo>(Expression<TFrom> from)
    where TFrom : class
    where TTo : class
{
    // figure out which types are different in the function-signature
    var fromTypes = from.Type.GetGenericArguments();
    var toTypes = typeof(TTo).GetGenericArguments();
    if (fromTypes.Length != toTypes.Length)
        throw new NotSupportedException(
            "Incompatible lambda function-type signatures");
    Dictionary<Type, Type> typeMap = new Dictionary<Type,Type>();
    for (int i = 0; i < fromTypes.Length; i++)
    {
        if (fromTypes[i] != toTypes[i])
            typeMap[fromTypes[i]] = toTypes[i];
    }

    // re-map all parameters that involve different types
    Dictionary<Expression, Expression> parameterMap
        = new Dictionary<Expression, Expression>();
    ParameterExpression[] newParams =
        new ParameterExpression[from.Parameters.Count];
    for (int i = 0; i < newParams.Length; i++)
    {
        Type newType;
        if(typeMap.TryGetValue(from.Parameters[i].Type, out newType))
        {
            parameterMap[from.Parameters[i]] = newParams[i] =
                Expression.Parameter(newType, from.Parameters[i].Name);
        }
        else
        {
            newParams[i] = from.Parameters[i];
        }
    }

    // rebuild the lambda
    var body = new TypeConversionVisitor(parameterMap).Visit(from.Body);
    return Expression.Lambda<TTo>(body, newParams);
}

这需要一个任意Expression<TFrom>的 和 a TTo，通过以下方式将其转换为 a Expression<TTo>：

  • TFrom找出/之间不同的类型TTo
  • 使用它来重新映射参数
  • 使用我们刚刚创建的表达式访问器
  • 最后为所需的签名构造一个新的 lambda 表达式

然后，将它们放在一起并公开我们的扩展方法：

public static class Helpers {
    public static Expression<Func<TTo, bool>> Convert<TFrom, TTo>(
        this Expression<Func<TFrom, bool>> from)
    {
        return ConvertImpl<Func<TFrom, bool>, Func<TTo, bool>>(from);
    }

    // insert from above: ConvertImpl
    // insert from above: TypeConversionVisitor
}

瞧！通用 lambda 转换例程，具有以下特定实现：

Expression<Func<Test, bool>> fc2 = fc1.Convert<TestDTO, Test>();
于 2012-12-22T22:30:44.333 回答
5

您可以使用AutoMapper（无表达式树）：

Mapper.CreateMap<Test, TestDTO>();

...

Func<TestDTO, bool> fc1 =
  (TestDTO c1) => c1.CustomerID <= 100 && c1.CustomerID >= 10;

Func<Test, bool> fc2 =
  (Test t) => fc1(Mapper.Map<Test, TestDTO>(t));
于 2012-12-22T22:43:58.610 回答