Erstellen eines Property-Setter-Delegaten

Ich haben erstellt Methoden für die Konvertierung einer Eigenschaft lambda Delegierter:

public static Delegate MakeGetter<T>(Expression<Func<T>> propertyLambda)
{
    var result = Expression.Lambda(propertyLambda.Body).Compile();
    return result;
}

public static Delegate MakeSetter<T>(Expression<Action<T>> propertyLambda)
{
    var result = Expression.Lambda(propertyLambda.Body).Compile();
    return result;
}

Diese Arbeit:

Delegate getter = MakeGetter(() => SomeClass.SomeProperty);
object o = getter.DynamicInvoke();

Delegate getter = MakeGetter(() => someObject.SomeProperty);
object o = getter.DynamicInvoke();

aber diese wird nicht kompilieren:

Delegate setter = MakeSetter(() => SomeClass.SomeProperty);
setter.DynamicInvoke(new object[]{propValue});

Delegate setter = MakeSetter(() => someObject.SomeProperty);
setter.DynamicInvoke(new object[]{propValue});

Den MakeSetter Linien ausfallen, mit "Der Typ der Argumente nicht entnommen werden kann, die aus der Verwendung. Versuchen Sie, den Typ der Argumente ausdrücklich."

Ist, was ich versuche zu tun möglich? Vielen Dank im Voraus.

InformationsquelleAutor der Frage Jim C | 2010-05-12

c#delegates lambda properties

Den Expression - API unterstützt diese Option .NET 4.0, aber leider ist der C# - compiler fügt keine extra-Süßigkeiten zu unterstützen. Aber die gute Nachricht ist, dass Sie trivial einen "get" - Ausdruck (der C# - compiler kann schreiben) und neu zu schreiben es als "set" Ausdruck.

Und noch besser, wenn Sie nicht haben .NET 4.0, es gibt immer noch mindestens zwei andere Möglichkeiten, ausführen von "set" über einen Ausdruck geschrieben, als ein "get".

Hier sind Sie alle, zur info:

using System;
using System.Linq.Expressions;
using System.Reflection;
class Foo {
    public string Bar { get; set; }
    static void Main() {
        //take a "get" from C#
        Expression<Func<Foo, string>> get = foo => foo.Bar;

        //re-write in .NET 4.0 as a "set"
        var member = (MemberExpression)get.Body;
        var param = Expression.Parameter(typeof(string), "value");
        var set = Expression.Lambda<Action<Foo, string>>(
            Expression.Assign(member, param), get.Parameters[0], param);

        //compile it
        var action = set.Compile();
        var inst = new Foo();
        action(inst, "abc");
        Console.WriteLine(inst.Bar); //show it working

        //==== reflection
        MethodInfo setMethod = ((PropertyInfo)member.Member).GetSetMethod();
        setMethod.Invoke(inst, new object[] { "def" });
        Console.WriteLine(inst.Bar); //show it working

        //==== Delegate.CreateDelegate
        action = (Action<Foo, string>)
            Delegate.CreateDelegate(typeof(Action<Foo, string>), setMethod);
        action(inst, "ghi");
        Console.WriteLine(inst.Bar); //show it working
    }
}

InformationsquelleAutor der Antwort Marc Gravell

Als pro meine Kommentare - da links gehen tot - ich habe den vollständigen code als eine Antwort auf die Frage. JA, es ist möglich, das zu tun, was der OP fordert. und hier ist ein kleines Juwel von Nick vorführt. Nick credits dieser Seite und einer anderen Seite für seine komplette Lösung zusammen mit performance-Metriken. Ich, dass unten anstelle von nur ein link.

//returns property getter
public static Func<TObject, TProperty> GetPropGetter<TObject, TProperty>(string propertyName)
{
    ParameterExpression paramExpression = Expression.Parameter(typeof(TObject), "value");

    Expression propertyGetterExpression = Expression.Property(paramExpression, propertyName);

    Func<TObject, TProperty> result =
        Expression.Lambda<Func<TObject, TProperty>>(propertyGetterExpression, paramExpression).Compile();

    return result;
}

//returns property setter:
public static Action<TObject, TProperty> GetPropSetter<TObject, TProperty>(string propertyName)
{            
    ParameterExpression paramExpression = Expression.Parameter(typeof(TObject));

    ParameterExpression paramExpression2 = Expression.Parameter(typeof(TProperty), propertyName);

    MemberExpression propertyGetterExpression = Expression.Property(paramExpression, propertyName);

    Action<TObject, TProperty> result = Expression.Lambda<Action<TObject, TProperty>>
    (
        Expression.Assign(propertyGetterExpression, paramExpression2), paramExpression, paramExpression2
    ).Compile();

    return result;
}

InformationsquelleAutor der Antwort Stix

4

Action<T> stellt einen Delegaten, die einen parameter vom Typ T und gibt nichts zurück. Die lambda-Ausdrücke, die Sie MakeSetter stellen die Delegierten, die nehmen keine parameter und Rückgabe entweder SomeClass.SomeProperty oder someObject.SomeProperty.

Fehlermeldungen, die Sie bekommen, sind aufgrund der Tatsache, dass der compiler nicht darauf schließen, die Typen von lambda-Ausdrücken, die Sie vorbei sind in der MakeSetter Methode, weil das, was Sie übergeben haben, und was die Methode erwartet, sind nicht synchron.

InformationsquelleAutor der Antwort Jason Punyon

Ihre MakeSetter erwartet ein Action<T> und übergeben Sie es einem Func<T> (() => someObject.SomeProperty). Versuchen Sie Folgendes:

Delegate setter = MakeSetter((prop) => {someObject.SomeProperty = prop;});
setter.DynamicInvoke(new object[]{propValue});

BEARBEITEN nicht Aussehen wie Sie können convert-Anweisung Lambda-Ausdrücke in Ausdrücke. Dies ist etwas von einer Runde über Art und Weise, es zu tun, ohne Ausdrücke - direkt an die Delegierten:

class Test2 {
    delegate void Setter<T>(T value);

    public static void Test() {
        var someObject = new SomeObject();
        Setter<string> setter = (v) => { t.SomeProperty = v; };
        setter.DynamicInvoke(new object[]{propValue});
    }
}

InformationsquelleAutor der Antwort Igor Zevaka

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.