如何在不同(但兼容)模型之间转换lambda表达式?
本文关键字:之间 模型 转换 lambda 表达式 | 更新日期: 2023-09-27 17:49:23
(基于一封电子邮件对话,现在记录下来用于信息共享)我在不同的层使用了两个模型:
public class TestDTO {
public int CustomerID { get; set; }
}
//...
public class Test {
public int CustomerID { get; set; }
}
和一个lambda表示我的DTO层:
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
类型)
?
要做到这一点,您必须完全重建表达式树;这些参数需要重新映射,并且现在与不同类型对话的所有成员访问都需要重新应用。幸运的是,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
中应用。在VisitMember
中,我们也检查了我们是否切换了类型(如果Visit
涉及到ParameterExpression
或另一个MemberExpression
,在任何时候都可能发生):如果有,我们将尝试找到同名的另一个成员。
// 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>
和TTo
,通过以下方式将其转换为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>();
您可以使用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));