C# Reflection - Wie Feld Wert für Struktur festlegen

Question

Wie kann ich Wert in Struct-Feld - myStruct.myField mit Reflektion mit DynamicMethod? Wenn ich setter(myStruct, 111) aufrufen, wurde der Wert nicht festgelegt, da MyStruct Werttyp ist. Console.WriteLine(myStruct.myField) zeigt den Wert 3.
Wie kann man die GetDelegate Methode ändern, um den Wert in myStruct.myField einzustellen?

public struct MyStruct 
{ 
    public int myField; 
} 

public delegate void SetHandler(object source, object value); 

private static SetHandler GetDelegate(Type type, FieldInfo fieldInfo) 
{ 
    DynamicMethod dm = new DynamicMethod("setter", typeof(void), new Type[] { typeof(object), typeof(object) }, type, true); 
    ILGenerator setGenerator = dm.GetILGenerator(); 

    setGenerator.Emit(OpCodes.Ldarg_0); 
    setGenerator.DeclareLocal(type); 
    setGenerator.Emit(OpCodes.Unbox_Any, type); 
    setGenerator.Emit(OpCodes.Stloc_0); 
    setGenerator.Emit(OpCodes.Ldloca_S, 0); 
    setGenerator.Emit(OpCodes.Ldarg_1); 
    setGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType); 
    setGenerator.Emit(OpCodes.Stfld, fieldInfo); 
    setGenerator.Emit(OpCodes.Ldloc, 0); 
    setGenerator.Emit(OpCodes.Box, type); 
    setGenerator.Emit(OpCodes.Ret); 
    return (SetHandler)dm.CreateDelegate(typeof(SetHandler)); 
} 

MyStruct myStruct = new MyStruct(); 
myStruct.myField = 3; 

FieldInfo fi = typeof(MyStruct).GetField("myField", BindingFlags.Public | BindingFlags.Instance); 

SetHandler setter = GetDelegate(typeof(MyStruct), fi); 
setter(myStruct, 111); 
Console.WriteLine(myStruct.myField); 

Answer 1

Bearbeiten: I made this mistake again - Spaß Tatsache; unbox-any gibt den Wert zurück; unbox gibt den Zeiger auf die Daten zurück, der in-Place muate ermöglicht.

Hier ist die Arbeits IL Generation:

setGenerator.Emit(OpCodes.Ldarg_0); 
    setGenerator.Emit(OpCodes.Unbox, type); 
    setGenerator.Emit(OpCodes.Ldarg_1); 
    setGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType); 
    setGenerator.Emit(OpCodes.Stfld, fieldInfo); 
    setGenerator.Emit(OpCodes.Ret); 

Aber! Dies mutiert eine Box-Kopie; Sie würden danach unbox brauchen:

object obj = myStruct; 
    setter(obj, 111); 
    MyStruct andBackAgain = (MyStruct)obj; 
    Console.WriteLine(andBackAgain.myField); 
    Console.WriteLine(myStruct.myField); 

Um es zu tun an Ort und Stelle, würden Sie wahrscheinlich brauchen die Methode eine ref MyStruct zu nehmen oder zu Rückkehr ein MyStruct. Sie könnte die Box-Kopie zurückgeben, aber das macht es nicht viel einfacher zu bedienen. Ehrlich gesagt, es ist strittig: Strukturen sollten im Allgemeinen nicht veränderbar sein.

Answer 2

Ich denke, wie Servy in den Kommentaren hervorhebt, ist es wahrscheinlich besser, keine veränderbare Struktur zu haben und stattdessen eine Kopie der Struktur mit dem neuen Wert zu erstellen. Sie können die SetValueDirect-Methode auf der FieldInfo-Instanz verwenden, wenn Sie wirklich wollen Reflection zu mutieren die Struktur, aber es verwendet die undokumentierte __makeref Methode, um eine TypedReference zu erhalten.

Ich würde wirklich nicht empfehlen, diesen Code zu verwenden; es ist rein zu zeigen, dass dies möglich ist:

MyStruct myStruct = new MyStruct(); 
myStruct.myField = 3; 

FieldInfo fi = typeof(MyStruct).GetField("myField", BindingFlags.Public | BindingFlags.Instance); 
TypedReference reference = __makeref(myStruct); 
fi.SetValueDirect(reference, 111); 
Console.WriteLine(myStruct.myField); //prints 111 

Answer 3

zu anderen Antworten hinzuzufügen, können Sie tatsächlich innerhalb der Delegat Box, solange Ihre Methode auch die modifizierte Struktur zurückgibt.

Da mein IL-fu ist nicht so toll, das ist, wie Sie es mit plain tun würde:

// the good side is that you can use generic delegates for added type safety 
public delegate T SetHandler<T>(T source, object value); 

private static SetHandler<T> GetDelegate<T>(FieldInfo fieldInfo) 
{ 
    return (s, val) => 
    { 
     object obj = s; // we have to box before calling SetValue 
     fieldInfo.SetValue(obj, val); 
     return (T)obj; 
    }; 
} 

Dies bedeutet, müssen Sie den Rückgabewert wie folgt holen:

SetHandler<MyStruct> setter = GetDelegate<MyStruct>(fi); 
myStruct = setter(myStruct, 111); 
Console.WriteLine(myStruct.myField); 

Aber es ist nicht notwendig, es vor dem Aufruf der setter zu boxen.

Alternativ können Sie die Struktur mit dem ref Schlüsselwort übergeben, was würde:

public delegate void SetHandler<T>(ref T source, object value); 

private static SetHandler<T> GetDelegate<T>(FieldInfo fieldInfo) 
{ 
    return (ref T s, object val) => 
    { 
     object obj = s; 
     fieldInfo.SetValue(obj, val); 
     s = (T)obj; 
    }; 
} 

SetHandler<MyStruct> setter = GetDelegate<MyStruct>(fi); 
setter(ref myStruct, 111); // no need to return anymore 
Console.WriteLine(myStruct.myField); 

Answer 4

Hier ist der Code mit ref:

public delegate void SetHandler<T>(ref T source, object value) where T : struct; 

     private static SetHandler<T> GetDelegate<T>(FieldInfo fieldInfo) where T : struct 
     { 
      var type = typeof(T); 
      DynamicMethod dm = new DynamicMethod("setter", typeof(void), new Type[] { type.MakeByRefType(), typeof(object) }, type, true); 
      ILGenerator setGenerator = dm.GetILGenerator(); 

      setGenerator.Emit(OpCodes.Ldarg_0); 
      setGenerator.DeclareLocal(type); 
      setGenerator.Emit(OpCodes.Ldarg_0); 
      setGenerator.Emit(OpCodes.Ldnull); 
      setGenerator.Emit(OpCodes.Stind_Ref); 
      setGenerator.Emit(OpCodes.Ldarg_1); 
      setGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType); 
      setGenerator.Emit(OpCodes.Stfld, fieldInfo); 
      setGenerator.Emit(OpCodes.Ldloc, 0); 
      setGenerator.Emit(OpCodes.Box, type); 
      setGenerator.Emit(OpCodes.Ret); 
       return (SetHandler<T>)dm.CreateDelegate(typeof(SetHandler<>).MakeGenericType(type)); 
     } 

     static void Main(string[] args) 
     { 
      MyStruct myStruct = new MyStruct(); 
      myStruct.myField = 3; 

      FieldInfo fi = typeof(MyStruct).GetField("myField", BindingFlags.Public | BindingFlags.Instance); 

      var setter = GetDelegate<MyStruct>(fi); 
      setter(ref myStruct, 111); 
      Console.WriteLine(myStruct.myField); 
     } 

Answer 5

Der einfachste Weg, Reflection Felder verwenden zu setzen oder Eigenschaften einer Struktur besteht darin, die Struktur zu boxen, die Box-Struktur an SetField oder SetProperty weiterzuleiten und dann die Struktur zu entpacken, sobald alle gewünschten Manipulationen abgeschlossen sind.

public static class refStructTest 
{ 
    struct S1 
    { 
     public int x; 
     public int y { get; set; } 
     public override string ToString() 
     { 
      return String.Format("[{0},{1}]", x, y); 
     } 
    } 
    public static void test() 
    { 
     var s = default(S1); 
     s.x = 2; 
     s.y = 3; 
     Object obj = s; 
     var fld = typeof(S1).GetField("x"); 
     var prop = typeof(S1).GetProperty("y"); 
     fld.SetValue(obj,5); 
     prop.SetValue(obj,6,null); 
     s = (S1)obj; 
     Console.WriteLine("Result={0}", s); 
    } 
} 

Nach der ECMA-Dokumentation wird jeder Wert Typ mit zwei Arten von Dingen verbunden: ein Speicherplatztyp und einem Haufen Objekttyp. Der Heap-Objekttyp verhält sich wie alle Heap-Objekttypen mit Referenzsemantik. Die Übergabe eines Verweises auf ein Heap-Objekt an eine Methode wie SetValue wird somit das Objekt ändern, an das die Referenz übergeben wurde.

Hinweis für VB-Benutzer: VB.NET hat ein wirklich ärgerliches Verhalten, das fast Sinn im Option Strict On Dialekt machen, die aber existiert auch im Option Strict Off Dialekt: Wenn ein Variable Kompilierung-Typs Object, die hält einen Verweis auf einem Die Boxed-Struktur wird einer anderen Variablen desselben Typs zugewiesen oder als Parameter des Typs Object übergeben. VB.NET speichert oder übergibt einen Verweis auf eine Kopie des ursprünglichen Objekts. Wenn Sie Code wie oben in VB.NET schreiben, sollte man obj vom Typ ValueType statt Object machen, um solches Verhalten zu verhindern.