Expression Tree how do I capture a local variable

Question

I'm currently working towards creating dynamic expressions and I have the following scenario, which I'd like help to achieve.

given:

public class planet {
    public string name { get;set; }
}

class someTestClass {
    [Test]
    public void Planet_Exists_Statically(){
        var planetName = "earth";
        var planets = new List<planet> {new planet {name = planetName}};
        var found = planets.Exists(MakePredicate(planetName));
        Assert.IsTrue(found);
    }

    [Test]
    public void Planet_Exists_Statically(){
        var planetName = "earth";
        var planets = new List<planet> {new planet {name = planetName}};
        var found = planets.Exists(MakeDynamicPredicate(planetName));
        Assert.IsTrue(found);
    }

    private Predicate<planet> MakePredicate(string planetName){
        Expression<Predicate<planet>> pred = p => p.name == planetName;
        return pred.Compile();
    }

    private Predicate<planet> MakeDynamicPredicate(string planetName){
        var parm = Expression.Parameter(typeof(planet), "p")
        var pred = Expression.Lambda<Predicate<planet>>(
                    Expression.ReferenceEqual(
                        Expression.Property(parm, typeof(planet), "name"), 
                        **???WHAT GOES HERE???**,
                        parm);
        return pred.Compile();
    }
}

So my issue is that I can't get the predicate returned from the MakeDynamicPredicate to be equal to the one generated by the MakePredicate function.

I read a reply post from Jon Skeet, but don't understand how to implement the ConstantExpression so that the local variable is captured...

Any help would be greatly appreciated.

Additional info: going forward I may not know the class that is being used so it will eventually be abstracted to be more generic.

If you mention some post (the one from Jon Skeet), it would be helpful if you linked to it. — svick, May 15 '13 at 17:15
sorry I went ahead and made Jon's name a link to the answer he provided — ermagana, May 15 '13 at 17:56

score 2 · Accepted Answer · answered May 15 '13 at 17:16

2

In your case, you don't actually need to capture any local variable, you can just use Expression.Constant(planetName).

If you then call it with, for example, MakeDynamicPredicate("Pluto"), the generated expression will be as if you wrote p => p.name == "Pluto".

answered May 15 '13 at 17:16

svick

236,525
50
385
514

thanks for the suggestion, but I want to be able to have the expression return as p => p.name == planetName – ermagana May 15 '13 at 17:58
@ermagana Why? It wouldn't make any difference in your case. – svick May 15 '13 at 18:33
this specific instance wouldn't make a difference, but I'm building up toward a more generic design, I'd also like to be able to know how to do it in general since it should be possible, at least from what I understand. – ermagana May 15 '13 at 19:13

score 2 · Answer 2 · answered May 17 '13 at 09:31

As you can read in Jon's post you need some object to store your variable. For MakePredicate it will be created by compiler, for MakeDynamicPredicate you'll have to do it yourself. First of all we need a class for variable value storage.


class someTestClass {
...
        private class ValueHolder
        {
            public string Value;
        }
...
}

Now you put your planetName into an instance of the ValueHolder and make a Member Access expression for using it in your predicate expression.


private Predicate MakeDynamicPredicate(string planetName){

        var valueHolder = new ValueHolder
        {
            Value = value
        };

        var valueExpr = Expression.MakeMemberAccess(
            Expression.Constant(valueHolder),
            valueHolder.GetType().GetField("Value"));

        var parm = Expression.Parameter(typeof(planet), "p")
        var pred = Expression.Lambda>(
                    Expression.ReferenceEqual(
                        Expression.Property(parm, typeof(planet), "name"), 
                        valueExpr,
                        parm);

}

P.S. it often makes sense to take a look at the compiler generated code (e.g. with ILSpy) to better understand how various epxressions are created.

Expression Tree how do I capture a local variable

2 Answers2