Reading a property value with a lambda expression

Question

I'm writing a file generic block for my application and started with using Lambda expressions for managing my rule sets for block generation to avoid the pitfalls of magic strings, configuration hell etc.

Inside my mapping class I have lines similar to:

Map(x => x.Name).Length(20).PadLeft(true).PaddingChar("#");

This works fine and isn't where my question dwells, where I setup saving my information about the expression is in the Map method:

public override IPropertyMap Map(Expression<Func<T, object>> expression)
{
    var propertyMap = new FixedLengthPropertyMap
          {
              //Length = 20,
              //PaddingCharacter = " ",
              PadLeft = false,
              PropertyInfo = ReflectionHelper.GetProperty(expression)
          };

    _properties.Add(propertyMap);

    return propertyMap;
}

_properties is just a List<IPropertyMap> that stores my info where my question from what is the best way to have a real object's data be read from the properties currently I came up with something similar to this:

var map = new AgentMap();
var agent = new Agent {Name = "Bob"};

string output = map.Write(agent);

public override string Write<T>(T agent)
{
    var initial = _properties[0];
    return initial.PropertyInfo.GetValue(agent, null) as string;
}

Is there a better way than using the GetValue method since earlier on I'm using an expression tree?

Answer 1

I don't see why you really need to use expression trees at all. Just make the Map method take a Func<T, object> and store that:

public override IPropertyMap Map(Func<T, string> fetcher)
{
    var propertyMap = new FixedLengthPropertyMap
          {
              //Length = 20,
              //PaddingCharacter = " ",
              PadLeft = false,
              Delegate = fetcher // Delegate is of type Delegate
          };

    _properties.Add(propertyMap);

    return propertyMap;
}

Then:

public override string Write<T>(T agent)
{
    var initial = _properties[0];
    Func<T, string> fetcher = (Func<T, string>) initial.Delegate;
    return fetcher(agent);
}

Is there any reason you particularly wanted to know the property and use an expression tree?

Answer 2

In part, it depends on what your scenario is. The "simple" answer is to just compile the expression and invoke it, but that has a potential performance impact if you are doing it in a tight loop (passing a delegate would be a lot quicker).

I'm not sure whether if would apply in this particular case (because of the agent), but to avoid doing too much expression compilation, you can look for simple scenarios and read the value directly from the expression tree; a little bit of PropertyInfo/FieldInfo is going to be quicker than compiling it...

For more, look at TryEvaluate here, and how it is used with Compile as a backup strategy (although you have the advantage of a known delegate type).