在拉姆达前pression替换参数 [英] Replace parameter in lambda expression
问题描述
考虑到这一点code：
公共类Foo
{
公众诠释一个{搞定;组; }
公众诠释B {搞定;组; }
}私人无效测试（）
{
清单＆LT;富＆GT; FOOS =新的List＆LT;富＆GT;（）;
foos.Add（新的Foo（））;
foos.Add（新的Foo（））;
防爆pression＆LT;＆Func键LT;富，INT＆GT;＆GT; exp0 = F =＆GT; F.A * f.b;
防爆pression＆LT;＆Func键LT; INT＆GT;＆GT; EXP1 =（）=＆GT; FOOS [0] .A * FOOS [0] .B;
防爆pression＆LT;＆Func键LT; INT＆GT;＆GT; EXP2 =（）=＆GT; FOOS [1] .A * FOOS [1] .B;
}
你怎么能采取 exp0 并把它变成两位前pressions等同于 EXP1 和 EXP2 。请注意，我不希望只是评估 exp0 每个富在 FOOS ，而是得到两个新的前pressions。
[更新]
基本上，我希望能够扩展或扁平化传递给一个的LINQ 扩展方法的前pression如总和成一个前pression每件枚举，因为这些枚举将是静态的，因为我已经有code，上面写着前pressions不带参数（和然后把它们转化成另一种语言）。
我使用了 MetadataToken 为具有特定属性（在这种情况下属性引用 A 和 b 会有这个属性），并用它与相关的C＃性能到另一种语言的变量的字典：
富富=新的Foo（）;
防爆pression＆LT;＆Func键LT; INT＆GT;＆GT; EXP =（）=＆GT; foo.a * foo.a + foo.b;
字符串RESULT1 =调用getResult（EXP）; //得到v_001 * v_001 + v_002清单＆LT;富＆GT;敌人=新的List＆LT;富＆GT;（）;
foes.Add（新的Foo（））;
foes.Add（新的Foo（））;
防爆pression＆LT;＆Func键LT; INT＆GT;＆GT; EXP2 =（）=＆GT; foes.Sum（F =＆GT; F.A * F.A + f.b）;
字符串结果2 =调用getResult（EXP2）; //应该得到（v_001 * v_001 + v_002）+（v_003 * v_003 + v_004）
我会做这种方式：
写参数替代前pression-游客的操纵原来的前pression如下：
- 摆脱了参数的不完全从拉姆达签名想要的。
- 替换参数的所有使用与所需的索引前pression。
下面是一个快速和肮脏的样品我刮起了基于我早些时候回答在一个不同的问题：
公共静态类ParameterReplacer
{
//产生前pression等同于'前pression
//除了与目标前pression替换成'源'参数。
公共静态防爆pression＆LT; TOutput＆GT;更换＆LT; TInput，TOutput＆GT;
（防爆pression＆LT; TInput＆GT;前pression，
ParameterEx pression源，
防爆pression目标）
{
返回新ParameterReplacerVisitor＆LT; TOutput＆GT;（源，目标）
.VisitAndConvert（如pression）;
} 私有类ParameterReplacerVisitor＆LT; TOutput＆GT; ：防爆pressionVisitor
{
私人ParameterEx pression _source;
私人防爆pression _target; 公共ParameterReplacerVisitor
（ParameterEx pression源，防爆pression目标）
{
_source =来源;
_target =目标;
} 内部防爆pression＆LT; TOutput＆GT; VisitAndConvert＆LT; T＆GT;（防爆pression＆LT; T＆GT;根）
{
返回（前pression＆LT; TOutput＆GT;）VisitLambda（根）;
} 保护覆盖防爆pression VisitLambda＆LT; T＆GT;（防爆pression＆LT; T＆gt;节点）
{
//别碰所有的参数，除了我们要替换的。
VAR参数= node.Parameters
。凡（P =＆GT;！P = _source）; 返回前pression.Lambda＆LT; TOutput＆GT;（参观（node.Body），参数）;
} 保护覆盖防爆pression VisitParameter（ParameterEx pression节点）
{
//与目标替换源，访问其他PARAMS如常。
返回节点== _source？ _target：base.VisitParameter（节点）;
}
}
}
为您的方案使用（测试）：
VAR zeroIndexIndexer =前pression.MakeIndex
（防爆pression.Constant（FOOS）
typeof运算（列表＆LT;富＆GT;）的getProperty（项目）。
新的[] {防爆pression.Constant（0）}）;
//的下面的ToString（）如下所示：
//（）= GT; （值（System.Collections.Generic.List`1 [App.Foo]）。项目[0] .A
// *值（System.Collections.Generic.List`1 [App.Foo]）。项目[0] .B）
VAR exp1Clone = ParameterReplacer.Replace＆LT;＆Func键LT;富，INT＆gt;中Func键＆LT; INT＆GT;＆GT;
（exp0，exp0.Parameters.Single（），zeroIndexIndexer）;
Considering this code:
public class Foo
{
public int a { get; set; }
public int b { get; set; }
}
private void Test()
{
List<Foo> foos = new List<Foo>();
foos.Add(new Foo());
foos.Add(new Foo());
Expression<Func<Foo, int>> exp0 = f => f.a * f.b;
Expression<Func<int>> exp1 = () => foos[0].a * foos[0].b;
Expression<Func<int>> exp2 = () => foos[1].a * foos[1].b;
}
How can you take exp0 and turn it into two expressions identical to exp1 and exp2. Note that I don't want to just evaluate exp0 for each Foo in foos, but instead get two new expressions.
[Update]:
Basically, I want to be able to expand or "flatten" an expression passed to a Linq extension method such as Sum into one expression per item in the enumeration since these enumerations will be static, and because I already have code that reads expressions that don't take parameters (and then turns them into another language).
I'm using the MetadataToken as a references to properties that have a certain attribute (in this case a and b would have this attribute) and using it with a dictionary that correlates C# properties to another language's variables:
Foo foo = new Foo();
Expression<Func<int>> exp = () => foo.a * foo.a + foo.b;
string result1 = GetResult(exp); // gets "v_001 * v_001 + v_002"
List<Foo> foes = new List<Foo>();
foes.Add(new Foo());
foes.Add(new Foo());
Expression<Func<int>> exp2 = () => foes.Sum(f => f.a * f.a + f.b);
string result2 = GetResult(exp2); // should get "(v_001 * v_001 + v_002) + (v_003 * v_003 + v_004)"
I would do it this way:
Write a parameter-replacer expression-visitor that manipulates the original expression as follows:
- Gets rid of the parameter you don't want entirely from the lambda signature.
- Replaces all uses of the parameter with the desired indexer expression.
Here's a quick and dirty sample I whipped up based on my earlier answer on a different question:
public static class ParameterReplacer
{
// Produces an expression identical to 'expression'
// except with 'source' parameter replaced with 'target' expression.
public static Expression<TOutput> Replace<TInput, TOutput>
(Expression<TInput> expression,
ParameterExpression source,
Expression target)
{
return new ParameterReplacerVisitor<TOutput>(source, target)
.VisitAndConvert(expression);
}
private class ParameterReplacerVisitor<TOutput> : ExpressionVisitor
{
private ParameterExpression _source;
private Expression _target;
public ParameterReplacerVisitor
(ParameterExpression source, Expression target)
{
_source = source;
_target = target;
}
internal Expression<TOutput> VisitAndConvert<T>(Expression<T> root)
{
return (Expression<TOutput>)VisitLambda(root);
}
protected override Expression VisitLambda<T>(Expression<T> node)
{
// Leave all parameters alone except the one we want to replace.
var parameters = node.Parameters
.Where(p => p != _source);
return Expression.Lambda<TOutput>(Visit(node.Body), parameters);
}
protected override Expression VisitParameter(ParameterExpression node)
{
// Replace the source with the target, visit other params as usual.
return node == _source ? _target : base.VisitParameter(node);
}
}
}
Usage for your scenario (tested):
var zeroIndexIndexer = Expression.MakeIndex
(Expression.Constant(foos),
typeof(List<Foo>).GetProperty("Item"),
new[] { Expression.Constant(0) });
// .ToString() of the below looks like the following:
// () => (value(System.Collections.Generic.List`1[App.Foo]).Item[0].a
// * value(System.Collections.Generic.List`1[App.Foo]).Item[0].b)
var exp1Clone = ParameterReplacer.Replace<Func<Foo, int>, Func<int>>
(exp0, exp0.Parameters.Single(), zeroIndexIndexer);
这篇关于在拉姆达前pression替换参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
