How do I set a field value in an C# Expression tree?

Question

Given:

FieldInfo field = <some valid string field on type T>;
ParameterExpression targetExp = Expression.Parameter(typeof(T), "target");
ParameterExpression valueExp = Expression.Parameter(typeof(string), "value");

How do I compile a lambda expression to set the field on the "target" parameter to "value"?

Answer 1

You can't. Expression trees don't have a node for field assignment, at least not in .NET 3.5.

In .NET 4, there will indeed be a node for that, as the DLR expression trees are being folded into the System.Linq.Expressions namespace.

To do what you want, you'll have to use System.Reflection.Emit instead. It's not hard though:

class Program
{
    class MyObject
    {
        public int MyField;
    }

    static Action<T,TValue> MakeSetter<T,TValue>(FieldInfo field)
    {
        DynamicMethod m = new DynamicMethod(
            "setter", typeof(void), new Type[] { typeof(T), typeof(TValue) }, typeof(Program));
        ILGenerator cg = m.GetILGenerator();

        // arg0.<field> = arg1
        cg.Emit(OpCodes.Ldarg_0);
        cg.Emit(OpCodes.Ldarg_1);
        cg.Emit(OpCodes.Stfld, field);
        cg.Emit(OpCodes.Ret);

        return (Action<T,TValue>) m.CreateDelegate(typeof(Action<T,TValue>));
    }

    static void Main()
    {
        FieldInfo f = typeof(MyObject).GetField("MyField");

        Action<MyObject,int> setter = MakeSetter<MyObject,int>(f);

        var obj = new MyObject();
        obj.MyField = 10;

        setter(obj, 42);

        Console.WriteLine(obj.MyField);
        Console.ReadLine();
    }
}

Answer 2

I think you can actually, please note the code below is just a snippet:

Create a MethodCallExpression and call the FieldInfo.SetValue() method:

MethodInfo setValueInfo = typeof(FieldInfo).GetMethod("SetValue");
ParameterExpression targetExp = Expression.Parameter(typeof(T), "target");
ParameterExpression valueExp = Expression.Parameter(typeof(string), "value");
Expression setExp = Expression.Call(targetExp, setValueInfo, targetExp, valueExp);

Still uses reflection though.

Hope that helps!

Answer 3

Setting a field is, as already discussed, problematic. You can can (in 3.5) a single method, such as a property-setter - but only indirectly. This gets much easier in 4.0, as discussed here. However, if you actually have properties (not fields), you can do a lot simply with Delegate.CreateDelegate:

using System;
using System.Reflection;
public class Foo
{
    public int Bar { get; set; }
}
static class Program
{
    static void Main()
    {
        MethodInfo method = typeof(Foo).GetProperty("Bar").GetSetMethod();
        Action<Foo, int> setter = (Action<Foo, int>)
            Delegate.CreateDelegate(typeof(Action<Foo, int>), method);

        Foo foo = new Foo();
        setter(foo, 12);
        Console.WriteLine(foo.Bar);
    }
}

Answer 4

private static Action<object, object> CreateSetAccessor(FieldInfo field)
 {
  DynamicMethod setMethod = new DynamicMethod(field.Name, typeof(void), new[] { typeof(object), typeof(object) });
  ILGenerator generator = setMethod.GetILGenerator();
  LocalBuilder local = generator.DeclareLocal(field.DeclaringType);
  generator.Emit(OpCodes.Ldarg_0);
  if (field.DeclaringType.IsValueType)
  {
   generator.Emit(OpCodes.Unbox_Any, field.DeclaringType);
   generator.Emit(OpCodes.Stloc_0, local);
   generator.Emit(OpCodes.Ldloca_S, local);
  }
  else
  {
   generator.Emit(OpCodes.Castclass, field.DeclaringType);
   generator.Emit(OpCodes.Stloc_0, local);
   generator.Emit(OpCodes.Ldloc_0, local);
  }
  generator.Emit(OpCodes.Ldarg_1);
  if (field.FieldType.IsValueType)
  {
   generator.Emit(OpCodes.Unbox_Any, field.FieldType);
  }
  else
  {
   generator.Emit(OpCodes.Castclass, field.FieldType);
  }
  generator.Emit(OpCodes.Stfld, field);
  generator.Emit(OpCodes.Ret);
  return (Action<object, object>)setMethod.CreateDelegate(typeof(Action<object, object>));
 }