Field Setter / Getter à l'aide de Delegate

c# delegates expression-trees field mono

Question

Ceci est mon code de test simple. Je souhaite créer un lien d'affectation de champ entre 2 objets. Le champ est déterminé lors de l'exécution à l'aide de la réflexion en mettant en cache le délégué de sa méthode setter / getter. Mais, d'une certaine manière, cela ne fonctionne pas. La mission ne fonctionne pas; j'ai peut-être commis une erreur stupide. Où est-ce que je me trompe?

public static class AssignmentExpression
{
    public static Expression Create(Expression left, Expression right)
    {
        MethodInfo m = typeof(AssignmentExpression)
                  .GetMethod("AssignTo", BindingFlags.NonPublic | BindingFlags.Static)
                  .MakeGenericMethod(left.Type);

        return Expression.Call( null,m,left, right);
    }

    private static void AssignTo<T>(ref T left, T right)  
    {                                                     
        left = right;                                     
    }
}

public class FieldLink
{
    protected Delegate srcGetter;
    protected Delegate dstSetter;

    public FieldLink(FieldInfo srcObject, FieldInfo dstObject)
    {
        this.srcGetter = FieldLink.createGetter(srcObject);
        this.dstSetter = FieldLink.createSetter(dstObject);
    }

    public void update<T>(T dst, T src)
    {
        this.dstSetter.DynamicInvoke(dst, this.srcGetter.DynamicInvoke(src));
    }

    protected static Delegate createGetter(FieldInfo field)
    {
        ParameterExpression objParm = Expression.Parameter(field.DeclaringType, "obj");
        Type delegateType = typeof(Func<,>).MakeGenericType(field.DeclaringType, field.FieldType);
        MemberExpression fieldExpr = Expression.Field(objParm, field.Name);
        LambdaExpression lambda = Expression.Lambda(delegateType, fieldExpr, objParm);
        return lambda.Compile();
    }

    protected static Delegate createSetter(FieldInfo field)
    {
        ParameterExpression objParm = Expression.Parameter(field.DeclaringType, "obj");
        ParameterExpression valueParm = Expression.Parameter(field.FieldType, "value");
        Type delegateType = typeof(Action<,>).MakeGenericType(field.DeclaringType, field.FieldType);
        MemberExpression memberExpr = Expression.Field(objParm, field.Name);
        Expression assignExpr = AssignmentExpression.Create(memberExpr, valueParm);
        LambdaExpression lambda = Expression.Lambda(delegateType, assignExpr, objParm, valueParm);
        return lambda.Compile();
    }
}

public class Test
{
    public int fieldInt = 0;
}

public class TestClass
{
    public Test a = new Test();
    public Test b = new Test();
    public void Start()
    {
        a.fieldInt = 5;

        Debug.Log("before a = " + a.fieldInt + " b = " + b.fieldInt);
        FieldLink testLink = new FieldLink(this.a.GetType().GetField("fieldInt"),
                                           this.b.GetType().GetField("fieldInt"));
        testLink.update(this.b, this.a);
        Debug.Log("after  a = " + a.fieldInt + " b = " + b.fieldInt);
        //here a.fieldInt should be equal to b.fieldInt, but somehow its unchanged!
    }
}

Réponse acceptée

Votre code semble fonctionner, mais peut-être pas exactement ce à quoi vous vous attendez. Lorsque vous appelez update vous passez b.fieldInt tant qu'argument left et a.fieldInt tant qu'argument right ; la méthode de update affecte ensuite la valeur de a.fieldInt (5) au champ b.fieldInt , ce qui donne aux deux objets une valeur de fieldInt égale à 5. Si vous inversez les arguments, les deux champs sont égaux à zéro. N'est-ce pas ce que vous attendez?

En passant (et vous avez peut-être d'autres raisons d'utiliser votre propre classe AssignmentExpression ), vous pouvez toutefois remplacer:

Expression assignExpr = AssignmentExpression.Create(memberExpr, valueParm);

...avec:

Expression assignExpr = Expression.Assign(memberExpr, valueParm);

... et vous obtenez le même résultat.



Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow