Gibt es eine Möglichkeit zu schaffen, einen Delegierten zum abrufen und festlegen von Werten für ein FieldInfo?

Feld Zugang nicht erfolgt über eine Methode (wie get-und Set-Methoden) - es ist ausgeführt mit einer IL Instruktion-also gibt es nichts, was Sie zuweisen einer Stellvertretung. Sie müssen mit dem expression-route zu erstellen, die einen "block" der code (effektiv IL) zugewiesen werden können, eine Stellvertretung.

[2019 edit: Seit diesem post war schon immer einer meiner Favoriten, es ist bittersüß zu beachten, dass der Ansatz, den ich hier zeige, wurde vollständig abgelöst, in meine eigenen Projekte, durch eine neue, ganz andere und viel elegantere Technik, die ich ausführlich an diese Antwort].

Mithilfe der neuen " ref Rückkehr " - Funktion in C# 7.0 kann der Prozess der Erstellung und Verwendung von Laufzeit dynamisch generierte get/set-Accessoren viel einfacher und syntaktisch transparent. Statt DynamicMethod zu emittieren separate getter und setter Funktionen für den Zugriff auf das Feld können Sie nun eine einzige Methode gibt eine verwalteten Zeiger-Typ Referenz auf dem Gebiet, der im wesentlichen einem einzigen accessor, der (wiederum) ermöglicht die bequeme ad-hoc - bekommen und set Zugang. Unten Stelle ich eine helper utility-Funktion vereinfacht die Generierung einer ByRef getter-Funktion für beliebige (D. H. private) Instanz-Feld in jeder Klasse.

      ➜ Für "nur-code", überspringen Sie den Hinweis weiter unten.

Als ein Beispiel, sagen wir, wir möchten den Zugriff auf eine private Instanz-Feld m_iPrivate eine int definiert in der Klasse OfInterestClass:

public class OfInterestClass
{
    private int m_iPrivate;
};

Weiter nehmen wir an, wir haben eine statische Feld "Referenz-getter" - Funktion, das dauert ein OfInterestClass Instanz und gibt den gewünschten Wert im Feld durch Verweis mit dem neuen C# 7 " ref Rückkehr " - Funktion (unten gebe ich code zu generieren solche Funktionen zur Laufzeit über DynamicMethod):

public static ref int __refget_m_iPrivate(this OfInterestClass obj)
{
     ///...
}

Solche Funktion ("ref-getter," sagen wir mal) ist alles, was wir brauchen, um zu haben vollständigen lese - /Schreibzugriff Zugriff auf das private Feld. In den folgenden Beispielen beachten Sie insbesondere die setter-aufrufen Vorgang—und die Demonstrationen mit dem (z.B.) ++ und += Betreiber—da die Anwendung dieser Operatoren direkt auf eine Aufruf der Methode Blick ein wenig ungewöhnlich, wenn Sie nicht up-to-Geschwindigkeit auf C#7.

void MyFunction(OfInterestClass oic)
{
    int the_value = oic.__refget_m_iPrivate();      //'get'
    oic.__refget_m_iPrivate() = the_value + 100;    //'set'

    ///or simply...
    oic.__refget_m_iPrivate() += 100;                //<-- yes, you can

    oic.__refget_m_iPrivate()++;                     //<-- this too, no problem

    ref int prv = ref oic.__refget_m_iPrivate();     //via "ref-local" in C#7
    prv++;
    foo(ref prv);                                    //all of these directly affect…
    prv = 999;                                       //…field m_iPrivate 'in-situ'
}

Da ist der Punkt, jeder Betrieb in diesen Beispielen gezeigt, manipuliert m_iPrivate in situ (d.h., direkt innerhalb dessen die Instanz oic), so dass alle und alle änderungen sind öffentlich sichtbar, es sofort. Es ist wichtig zu erkennen, dass dies bedeutet, dass prv trotz int-eingegeben und lokal deklariert, verhält sich nicht wie ein typischer "local" - Variablen. Dies ist besonders bedeutsam für die gleichzeitige code; nicht nur sind die änderungen sichtbar vor MyFunction verlassen hat, aber jetzt mit C# 7, die Anrufer haben die Möglichkeit behalten eine ref return verwalteter Zeiger (als ref lokalen) und damit verändern Sie das Ziel für eine beliebig lange Zeit danach (wenn auch notwendigerweise verbleibenden unten der ref-Gewinnung stack frame, dass ist).

Natürlich ein Haupt-und offensichtliche Vorteil der Verwendung eines verwalteten Zeiger, die hier—und anderswo im Allgemeinen—ist, dass es weiter gültig bleiben (wieder, in seinem stack frame Lebensdauer), auch als oic—selbst ein Referenz-Typ-Instanz zugewiesen, in der GC heap verschoben werden kann, um während der garbage collection. Das ist ein gigantischer Unterschied versus native Zeiger.

Wie oben skizziert, die ref-getter ist ein static extension-Methode, die deklariert werden kann und/oder von überall aus genutzt. Aber wenn du in der Lage bist, zu erstellen Sie Ihre eigenen Klasse, die abgeleitet aus OfInterestClass (das ist, wenn OfInterestClass ist nicht versiegelt), können Sie diese sogar noch schöner. In einer abgeleiteten Klasse, Sie können aufzudecken die C# - syntax für die Verwendung der Basisklasse privaten Bereich, als ob es eine öffentliche Feld Ihrer abgeleiteten Klasse. Um dies zu tun, fügen Sie einfach eine C# nur-lese - ref return Eigenschaft zu Ihrer Klasse, die bindet die statische ref-get-Methode die aktuelle Instanz this:

public ref int m_iPrivate => ref __refget_m_iPrivate(this);

Hier, das Anwesen ist aus public so kann jeder Zugriff auf das Feld (über einen Verweis auf unsere abgeleitete Klasse). Wir haben im wesentlichen veröffentlicht das private Feld aus der Basis-Klasse. Jetzt, in der abgeleiteten Klasse (oder anderswo angemessen) Sie können eine oder alle der folgenden:

int v = m_iPrivate;                             //get the value

m_iPrivate = 1234;                              //set the value

m_iPrivate++;                                   //increment it

ref int pi = ref m_iPrivate;                    //reference as C# 7 ref local

v = Interlocked.Exchange(ref m_iPrivate, 9999); //even do in-situ atomic operations on it!

Wie Sie sehen können, weil die Eigenschaft, wie die früheren Methode, hat auch eine durch Verweis Rückgabewert, es verhält sich fast genau wie ein Feld funktioniert.

So, jetzt für die details. Wie schaffen Sie den statischen ref-getter Funktion, die ich oben zeigte? Mit DynamicMethod, das sollte trivial sein. Zum Beispiel, hier ist die IL code für ein traditionelles (von-Wert) statische getter-Funktion:

//static int get_iPrivate(OfInterestClass oic) => oic.m_iPrivate;
IL_0000: ldarg.0    
IL_0001: ldfld Int32 m_iPrivate/OfInterestClass
IL_0006: ret       

Und hier ist der IL-code, den wir wollen, statt über die ref-return):

//static ref int refget_iPrivate(OfInterestClass oic) => ref oic.m_iPrivate;
IL_0000: ldarg.0    
IL_0001: ldfld̲a Int32 m_iPrivate/OfInterestClass
IL_0006: ret     

Der einzige Unterschied zu den von-Wert-get-Methode ist, dass wir die ldflda (load Feld Adresse) opcode statt ldfld (load-Bereich). Also, wenn Sie gut praktiziert, mit DynamicMethod sollte es kein problem sein, richtig?

Falsch!...
    leider DynamicMethod nicht erlauben eine by-ref Rückgabewert!

Wenn Sie versuchen, rufen Sie die DynamicMethod Konstruktor angeben ByRef Typ als Rückgabe-Wert...

var dm = new DynamicMethod(
        "",                                 //method name
        typeof(int).MakeByRefType(),        //by-ref return type   <-- ERROR
        new[] { typeof(OfInterestClass) },  //argument type(s)
        typeof(OfInterestClass),            //owner type
        true);                              //private access

...die Funktion löst NotSupportedException mit der folgenden Meldung:

Den Rückgabetyp enthält einige ungültige Typ (D. H. null, ByRef)

Anscheinend diese Funktion nicht bekommen das memo auf C#7 und ref-zurück. Zum Glück fand ich eine einfache Lösung, die es bekommt, zu arbeiten. Wenn Sie eine non-ref-Typ in den Konstruktor als eine temporäre "dummy", aber dann sofort danach die Reflexion auf die neu erstellte DynamicMethod Instanz zu ändern m_returnType privaten Bereich werden die ByRef-Typ Typ (sic.) dass Sie tatsächlich wollen, dann scheint alles zu funktionieren nur fine.

Dinge zu beschleunigen, werde ich hier kurz auf die fertige generische Methode, die automatisiert den gesamten Prozess von der Erstellung/Rückgabe einer statischen ref-get-Funktion für die private Instanz-Feld U, dass der bereitgestellte name, und definiert in der Klasse T.

Wenn Sie wollen einfach nur den kompletten funktionierenden code, kopieren von unterhalb dieses Punktes am Ende

Zuerst müssen wir definieren einen Delegaten, der für die ref-getter, da ein Func<T,TResult> Delegierten mit ByRef Verwendung nicht deklariert werden. Zum Glück, die älteren delegate syntax funktioniert für so tun (Puh!).

public delegate ref U RefGetter<T, U>(T obj);

Ort die Delegierten, zusammen mit die folgende statische Funktion in einem zentralen utility-Klasse, wo beide zugegriffen werden können, die während Ihres gesamten Projekts. Hier ist die Finale ref-getter-Erstellung Funktion, die verwendet werden können zum erstellen einer statischen ref-getter für die so genannten Instanz-Feld in jeder Klasse.

public static RefGetter<T, U> create_refgetter<T, U>(String s_field)
{
    const BindingFlags bf = BindingFlags.NonPublic |
                            BindingFlags.Instance |
                            BindingFlags.DeclaredOnly;

    var fi = typeof(T).GetField(s_field, bf);
    if (fi == null)
        throw new MissingFieldException(typeof(T).Name, s_field);

    var s_name = "__refget_" + typeof(T).Name + "_fi_" + fi.Name;

    //workaround for using ref-return with DynamicMethod:
    //  a.) initialize with dummy return value
    var dm = new DynamicMethod(s_name, typeof(U), new[] { typeof(T) }, typeof(T), true);

    //  b.) replace with desired 'ByRef' return value
    dm.GetType().GetField("m_returnType", bf).SetValue(dm, typeof(U).MakeByRefType());

    var il = dm.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldflda, fi);
    il.Emit(OpCodes.Ret);

    return (RefGetter<T, U>)dm.CreateDelegate(typeof(RefGetter<T, U>));
}

Nun wieder zum Anfang dieses Artikels, können wir leicht bieten die __refget_m_iPrivate Funktion, habe alles angefangen. Statt eine statische Funktion direkt geschrieben in C#, verwenden wir die statische ref-getter-Erstellung-Funktion zu erstellen, die den Rumpf der Funktion zur Laufzeit und speichern Sie es in eine statische Delegaten typisierte Feld (mit der gleichen Signatur). Die syntax für das aufrufen von in der Instanz-Eigenschaft (wie gezeigt, oben und unten wiederholt) oder anderswo, ist das gleiche, als wenn der compiler in der Lage gewesen zu schreiben, die Funktion.

Schließlich zum cache, der dynamisch erstellten ref-getter, delegieren, legen Sie die folgende Zeile in static Klasse Ihrer Wahl. Ersetzen OfInterestClass mit dem Typ der Basis-Klasse int mit dem Feld Typ des privaten Feld, und ändern Sie den string-argument den Namen der private Bereich. Wenn Sie nicht in der Lage, erstellen Sie Ihre eigene Klasse, abgeleitet von OfInterestClass (oder nicht wollen), Sie sind fertig; nur dass dieses Feld public und Sie können es nennen, wie eine Funktion übergeben OfInterestClass Instanz zu verweisen, die können Sie Lesen, schreiben, oder überwachen Sie Ihre intgeschätzte private Feld "m_iPrivate."

//Static delegate instance of ref-getter method, statically initialized.
//Requires an 'OfInterestClass' instance argument to be provided by caller.
static RefGetter<OfInterestClass, int> __refget_m_iPrivate = 
                                create_refgetter<OfInterestClass, int>("m_iPrivate");

Optional, wenn Sie möchten, veröffentlichen Sie das versteckte Feld mit einem Reiniger oder mehrere Natürliche syntax können Sie eine (nicht-statische) proxy-Klasse von Ihrer eigenen, die entweder enthält eine Instanz—oder vielleicht sogar besser (wenn möglich), stammt aus—Bereich ausblenden Klasse OfInterestClass. Statt, die die Bereitstellung der Codezeile, die zuvor dargestellt, Global in einem static - Klasse, legen Sie Sie in Ihren proxy-Klasse statt, und dann auch noch die folgende Zeile hinzufügen:

//optional: ref-getter as an instance property (no 'this' argument required)
public ref int m_iPrivate => ref __refget_m_iPrivate(this);

Ich bin mir nicht bewusst, wenn Sie verwenden würden Expression, warum dann die Vermeidung von Reflexion? Die meisten Operationen der Expression beruhen auf Reflexion.

GetValue und SetValue selbst sind die get method und set method für die Felder, aber Sie sind nicht für einen bestimmten Bereich.

Felder sind nicht wie die Eigenschaften sind Sie die Felder, und es gibt keinen Grund zum generieren von get - /set-Methoden für jeden. Aber der Typ kann variieren mit verschiedenen Feldes und damit GetValue und SetValue definiert sind, die parameter/return value als object für die Varianz. GetValue ist auch eine abstrakte Methode, das heißt, für jede Klasse(noch Reflexion) überschreiben, die es werden müssen, innerhalb der gleichen Signatur.

Wenn Sie nicht Typ, dann sollte der folgende code tun:

public static void SomeMethod(FieldInfo fieldInfo) {
    var Getter=(Func<object, object>)fieldInfo.GetValue;
    var Setter=(Action<object, object>)fieldInfo.SetValue;
}

aber wenn Sie wollen, gibt es eine eingeschränkte Möglichkeit:

public static void SomeMethod<S, T>(FieldInfo fieldInfo)
    where S: class
    where T: class {
    var Getter=(Func<S, object>)fieldInfo.GetValue;
    var Setter=(Action<S, T>)fieldInfo.SetValue;
}

Dem Grund, dass das Getter noch Func<S, object>, möchten Sie vielleicht einen Blick:

Kovarianz und Kontravarianz in C#, Teil Drei: Methode Gruppe-Konvertierung Varianz auf Herr Lippert ' s blog.

ref return Einschränkung in DynamicMethod scheint Weg zu sein zumindest auf v4.0.30319.

Geändert diese Antwort von Glenn Slayden mit info von microsoft docs:

using System;
using System.Reflection;
using System.Reflection.Emit;

namespace ConsoleApp {
    public class MyClass {
        private int privateInt = 6;
    }

    internal static class Program {
        private delegate ref TReturn OneParameter<TReturn, in TParameter0>(TParameter0 p0);

        private static void Main() {
            var myClass = new MyClass();

            var method = new DynamicMethod(
                "methodName",
                typeof(int).MakeByRefType(), //<- MakeByRefType() here
                new[] {typeof(MyClass)}, 
                typeof(MyClass), 
                true); //skip visibility


            const BindingFlags bindings = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

            var il = method.GetILGenerator();
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldflda, typeof(MyClass).GetField("privateInt", bindings));
            il.Emit(OpCodes.Ret);

            var getPrivateInt = (OneParameter<int, MyClass>) method.CreateDelegate(typeof(OneParameter<int, MyClass>));

            Console.WriteLine(typeof(string).Assembly.ImageRuntimeVersion);
            Console.WriteLine(getPrivateInt(myClass));
        }
    }
}

Ausgänge:

6