Jak ustawić wartość pola w drzewie wyrażeń C#?

Ustawienie pola jest, jak już wspomniano, problematyczne. Można (w 3.5) jedną metodę, taką jak właściwość-setter-ale tylko pośrednio. W 4.0 jest to o wiele łatwiejsze, jak zostało to omówione TUTAJ . Jeśli jednak masz właściwości (nie Pola), możesz wiele zrobić po prostu za pomocą 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);
    }
}

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>));
    }

Raz trafiłem na te zajęcia. Może to pomoże:

public class GetterSetter<EntityType,propType>
{
    private readonly Func<EntityType, propType> getter;
    private readonly Action<EntityType, propType> setter;
    private readonly string propertyName;
    private readonly Expression<Func<EntityType, propType>> propertyNameExpression;

    public EntityType Entity { get; set; }

    public GetterSetter(EntityType entity, Expression<Func<EntityType, propType>> property_NameExpression)
    {
        Entity = entity;
        propertyName = GetPropertyName(property_NameExpression);
        propertyNameExpression = property_NameExpression;
        //Create Getter
        getter = propertyNameExpression.Compile();
        // Create Setter()
        MethodInfo method = typeof (EntityType).GetProperty(propertyName).GetSetMethod();
        setter = (Action<EntityType, propType>)
                 Delegate.CreateDelegate(typeof(Action<EntityType, propType>), method);
    }


    public propType Value
    {
        get
        {
            return getter(Entity);
        }
        set
        {
            setter(Entity, value);
        }
    }

    protected string GetPropertyName(LambdaExpression _propertyNameExpression)
    {
        var lambda = _propertyNameExpression as LambdaExpression;
        MemberExpression memberExpression;
        if (lambda.Body is UnaryExpression)
        {
            var unaryExpression = lambda.Body as UnaryExpression;
            memberExpression = unaryExpression.Operand as MemberExpression;
        }
        else
        {
            memberExpression = lambda.Body as MemberExpression;
        }
        var propertyInfo = memberExpression.Member as PropertyInfo;
        return propertyInfo.Name;
    }

Test:

var gs = new GetterSetter<OnOffElement,bool>(new OnOffElement(), item => item.IsOn);
        gs.Value = true;
        var result = gs.Value;

W. NET 3.5 istnieje sposób na ustawienie właściwości i pól z drzewami wyrażeń. Może to być jedyna opcja dla niektórych profili PCL, które nie obsługują Delegate.CreateDelegate (oprócz odbicia.Emitować):

• Dla pola sztuczką jest podanie pola jako parametru ref ,
  np. SetField(ref holder.Field, "NewValue");

• Właściwość (jak wskazuje Marc) można ustawić poprzez odzwierciedlenie i wywołanie jej metody setter.

Pełny dowód koncepcji jest dostarczany poniżej jako urządzenie testowe NUnit.

[TestFixture]
public class CanSetPropAndFieldWithExpressionTreeInNet35
{
    class Holder
    {
        public int Field;
        public string Prop { get; set; }
    }

    public static class FieldAndPropSetter
    {
        public static T SetField<T, TField>(T holder, ref TField field, TField value)
        {
            field = value;
            return holder;
        }

        public static T SetProp<T>(T holder, Action<T> setProp)
        {
            setProp(holder);
            return holder;
        }
    }

    [Test]
    public void Can_set_field_with_expression_tree_in_Net35()
    {
        // Shows how expression could look like:
        Func<Holder, Holder> setHolderField = h => FieldAndPropSetter.SetField(h, ref h.Field, 111);
        var holder = new Holder();
        holder = setHolderField(holder);
        Assert.AreEqual(111, holder.Field);

        var holderType = typeof(Holder);
        var field = holderType.GetField("Field");
        var fieldSetterMethod =
            typeof(FieldAndPropSetter).GetMethod("SetField")
            .MakeGenericMethod(holderType, field.FieldType);

        var holderParamExpr = Expression.Parameter(holderType, "h");
        var fieldAccessExpr = Expression.Field(holderParamExpr, field);

        // Result expression looks like: h => FieldAndPropSetter.SetField(h, ref h.Field, 222)
        var setHolderFieldExpr = Expression.Lambda<Func<Holder, Holder>>(
            Expression.Call(fieldSetterMethod, holderParamExpr, fieldAccessExpr, Expression.Constant(222)),
            holderParamExpr);

        var setHolderFieldGenerated = setHolderFieldExpr.Compile();
        holder = setHolderFieldGenerated(holder);
        Assert.AreEqual(222, holder.Field);
    }

    [Test]
    public void Can_set_property_with_expression_tree_in_Net35()
    {
        // Shows how expression could look like:
        Func<Holder, Holder> setHolderProp = h => FieldAndPropSetter.SetProp(h, _ => _.Prop = "ABC");
        var holder = new Holder();
        holder = setHolderProp(holder);
        Assert.AreEqual("ABC", holder.Prop);

        var holderType = typeof(Holder);
        var prop = holderType.GetProperty("Prop");
        var propSet = prop.GetSetMethod();

        var holderParamExpr = Expression.Parameter(holderType, "h");
        var callSetPropExpr = Expression.Call(holderParamExpr, propSet, Expression.Constant("XXX"));
        var setPropActionExpr = Expression.Lambda(callSetPropExpr, holderParamExpr);

        var propSetterMethod = typeof(FieldAndPropSetter).GetMethod("SetProp").MakeGenericMethod(holderType);

        // Result expression looks like: h => FieldAndPropSetter.SetProp(h, _ => _.Prop = "XXX")
        var setHolderPropExpr = Expression.Lambda<Func<Holder, Holder>>(
            Expression.Call(propSetterMethod, holderParamExpr, setPropActionExpr),
            holderParamExpr);

        var setHolderPropGenerated = setHolderPropExpr.Compile();
        holder = setHolderPropGenerated(holder);
        Assert.AreEqual("XXX", holder.Prop);
    }
}

Tylko dla kompletności tutaj jest getter:

    public static IEnumerable<Func<T, object>> GetTypeGetters<T>()
    {
        var fields = typeof (T).GetFields();

        foreach (var field in fields)
        {
            ParameterExpression targetExp = Expression.Parameter(typeof(T), "target");
            UnaryExpression boxedFieldExp = Expression.Convert(Expression.Field(targetExp, field), typeof(object));
            yield return  Expression.Lambda<Func<T,object>>(boxedFieldExp, targetExp).Compile();
        }
    }