Come aggirare l'errore "Valore restituito ByRef non supportato nell'invocazione di riflessione" in C#?

Question

Ho una libreria .Net fornita da una terza parte. Ho fatto una riflessione su una delle loro classi e ho trovato un metodo membro. La firma era ...

Byte& FooBar() 

Così, ho voluto chiamare questo metodo attraverso la riflessione e ottenuto l'eccezione "ByRef valore non supportato nella riflessione invocazione tornare."

Ecco che cosa ho provato ...

 var strm = new TheirClass(); 
     var t = strm.GetType(); 
     var ms = t.GetMembers(
        BindingFlags.Static|BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); 
     foreach (var m in ms) 
     { 
      Debug.WriteLine(String.Format("Name: {0}: {1}", m.Name, m.ToString())); 
      // ... 
      // Name: FooBar: Byte& FooBar() 
      // ... 
     } 
     var meth = t.GetMethod("FooBar"); 
     object returnValue = meth.Invoke(strm, new object[] { }); //throw exception 

Ho cercato la fornitura di parametri come nelle funzioni con parametri ref chiamare, ma che ha fatto alcuna differenza.

Mi piacerebbe aggirare questa eccezione in C#.

Answer 1

Per i commenti: ecco come può essere eseguito da CIL, che può essere generato da C#.

Speravo di utilizzare un DynamicMethod, ma non riesco a farlo funzionare senza creare un tipo di delegato personalizzato in fase di runtime, quindi ho dovuto usare AssemblyBuilder invece.

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

public delegate void CallBadFunction(Delegate d, Callback c); 
public delegate void Callback(ref int i); 

static class Program 
{ 
    static int i; 
    static object BadMethod() 
    { 
     return i; 
    } 

    static MethodInfo GetBadMethod() 
    { 
     return typeof(Program).GetMethod("BadMethod", BindingFlags.Static | BindingFlags.NonPublic); 
    } 

    static void Main() 
    { 
     var badMethod = GetBadMethod(); 

     var assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("-"), AssemblyBuilderAccess.Run); 
     var module = assembly.DefineDynamicModule("-"); 

     var badDelegate = module.DefineType("BadDelegateType", TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed, typeof(MulticastDelegate)); 
     var badDelegateCtor = badDelegate.DefineConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[] { typeof(object), typeof(IntPtr) }); 
     badDelegateCtor.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed); 
     var badDelegateInvoke = badDelegate.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig, typeof(int).MakeByRefType(), Type.EmptyTypes); 
     badDelegateInvoke.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed); 
     var badDelegateType = badDelegate.CreateType(); 

     var method = module.DefineGlobalMethod("-", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new[] { typeof(Delegate), typeof(Callback) }); 
     var il = method.GetILGenerator(); 
     il.Emit(OpCodes.Ldarg_1); 
     il.Emit(OpCodes.Ldarg_0); 
     il.Emit(OpCodes.Castclass, badDelegate); 
     il.Emit(OpCodes.Callvirt, badDelegateInvoke); 
     il.Emit(OpCodes.Callvirt, typeof(Callback).GetMethod("Invoke")); 
     il.Emit(OpCodes.Ret); 
     module.CreateGlobalFunctions(); 

     var callBadFunction = (CallBadFunction)Delegate.CreateDelegate(typeof(CallBadFunction), module.GetMethod("-")); 
     callBadFunction(badMethod.CreateDelegate(badDelegateType), (ref int i) => 
     { 
      i++; 
     }); 
    } 
} 

Dopo aver compilato questo programma, utilizzare ILDASM di smontarlo, e sostituire la definizione BadMethod s' da

.method private hidebysig static int32& 
     BadMethod() cil managed 
{ 
    ldsflda  int32 Program::i 
    ret 
} 

Questo lo trasforma in una funzione che restituisce int32&, che il seguente codice quindi gestire a chiamare . L'unica posizione C# consente i tipi int32& nei parametri di funzione (ref int), quindi per rendere utilizzabile il risultato, ho utilizzato una funzione di richiamata, che ottiene il valore restituito di BadMethod.

Answer 2

Grazie "hvd" per avermi indicato nella giusta direzione. Dopo un po 'di riflessione, ecco cosa mi è venuto in mente. È più semplice, ma per favore dimmi se vedi un difetto.

 var theirObj = new TheirClass(); 
     var t = theirObj.GetType(); 
     var fooBar = t.GetMethod("FooBar"); // Byte& FooBar() 

     DynamicMethod dm = new DynamicMethod(
      "MyFooBar", 
      MethodAttributes.Public | MethodAttributes.Static, 
      CallingConventions.Standard, 
      typeof(IntPtr), 
      new Type[] { typeof(TheirClass) }, 
      typeof(TheirClass), 
      true); 

     var ilg = dm.GetILGenerator(); 
     ilg.Emit(OpCodes.Ldarg_0); 
     ilg.Emit(OpCodes.Call, foobar); 
     ilg.Emit(OpCodes.Ret); 

     var del = dm.CreateDelegate(typeof(Func<TheirClass,IntPtr>)); 
     var ret = (IntPtr)del.DynamicInvoke(theirObject); 

     byte[] buf = new byte[theirObj.FooBarSize()]; //no need for reflection/IL here 
     // not sure about the following, it works, but should it be inside an "unsafe" section? 
     Marshal.Copy(ret, buf, 0, buf.Length); 

ho messo un semplice wrapper per il metodo incriminato e IL non interessa che io tratto il Byte & come IntPtr. Non sono ancora sicuro di fare una copia senza un wrapper non sicuro. Ma questo è buono per ora.