我想编写一个接受两个MemberExpression的方法,并生成一个委托,它接受两个对象 - source和target,并根据它的MemberExpression将源中的值分配给目标字段,根据第二个MemberExpression。对象不必是同一类型。 我正在寻找这样的东西:
public Action<TSource, TTarget> Map(Expression<Func<TSource, object>> getter, Expression<Func<TTarget, object>> setter)
{
var sourceField = getter.Body as MemberExpression;
var targetField = setter.Body as MemberExpression;
/*
* Now I would like to create a lambda expression which accepts TSource and TTarget instances,
* and assings TTarget according to the above getter and setter expressions. Kind of like:
* var assignExp = Expression.Assign(x, y);
* var lambda = Expression.Lambda<Action<TTarget, TSource>>( .... ).Compile();
* return lambda;
*/
}
用法:
Target target;
Source source;
//...
var action = Map(p => p.NestedField.Dummy, x => x.TargetName);
action(source, target);
我不明白如何构建要发送给Expression.Assign
的表达式。
此时,我不介意空值或字段初始化。请假设所有字段都已初始化。
答案 0 :(得分:1)
这样做:
public Action<TSource, TTarget> Map<TSource, TTarget>(Expression<Func<TSource, object>> getter, Expression<Func<TTarget, object>> setter)
{
var targetPropertyExpression = setter.Body as MemberExpression;
var targetProperty = targetPropertyExpression.Member as PropertyInfo;
return (src, tgt) => { targetProperty.SetValue(tgt, getter.Compile().Invoke(src)); };
}
它从第一个lambda表达式得到setter的属性,只返回一个动作,它根据第二个lambda表达式将值赋给属性,只需要调用它。
照顾<TSource, object>
,你可能还需要额外的演员。
答案 1 :(得分:1)
Assign用于生成赋值表达式,但在您的情况下,每个lambda表达式都有自己的参数,并且这两个参数都应该发送到新的lambda表达式。
因此在我的示例中,我生成新的assign表达式,然后创建一个新的lambda表达式,并将getter和setter表达式中的ParameterExpression
发送到新的lambda。
所以它应该是这样的:
以下是工作示例 - https://dotnetfiddle.net/uuPVAl和代码本身
using System;
using System.Linq.Expressions;
public class Program
{
public static void Main(string[] args)
{
Target target = new Target();
Source source = new Source()
{
NestedField = new NestedSource()
{
Dummy = "Hello world"
}
};
var action = Map<Source, Target>(p => p.NestedField.Dummy, x => x.TargetName);
action(source, target);
Console.WriteLine(target.TargetName);
}
public static Action<TSource, TTarget> Map<TSource, TTarget>(Expression<Func<TSource, object>> getter, Expression<Func<TTarget, object>> setter)
{
var sourceField = getter.Body as MemberExpression;
var targetField = setter.Body as MemberExpression;
// here we create new assign expression
var assign = Expression.Assign(targetField, sourceField);
// and then compile it with original two parameters
var lambda = Expression.Lambda<Action<TSource, TTarget>>(assign, getter.Parameters[0], setter.Parameters[0]);
return lambda.Compile();
}
}
public class Target
{
public string TargetName { get; set; }
}
public class NestedSource
{
public string Dummy { get; set; }
}
public class Source
{
public NestedSource NestedField { get; set; }
}
<强>更新强>
因此每个Lambda Expression都可以包含任何参数。从代码方面来看,它是ParameterExpression
。当您将表达式编写为典型代码时,它意味着函数参数,因此在您的情况下(p) => p.NestedField.Dummy
- (p)
是该函数的参数。并且body内部的表达式使用它 - p.NestedField.Dummy
,因此为了能够编译它 - lambda表达式需要知道该参数。
在这种情况下,您有两个用于目标和源的lambda表达式,并且每个表达式都有自己的参数 - (p)
和(x)
,每个表达式都使用自己的参数。但是在结果函数中我们需要同时使用它们,因为我们在函数中有两个参数,所以我们需要从源和目标重新发送原始ParameterExpression
到一个新的lambda。或者您可以创建一个新的ParameterExpression
,但是您需要创建一个新树,因为旧树将使用旧的ParameterExpression
。通常这样的事情是用ExpressionVisitor
类完成的,但在你的情况下我们可以重新发送原始表达式而不需要更改树体。