Как обойти ошибку, когда возвращаемое значение ByRef не поддерживается при вызове отражения в C#?

Согласно комментариям: вот как это можно сделать из CIL, который можно сгенерировать из C#.

Я надеялся использовать DynamicMethod, но мне не удалось заставить это работать без создания пользовательского типа делегата во время выполнения, поэтому вместо этого мне нужно было использовать AssemblyBuilder.

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++;
        });
    }
}

После компиляции этой программы используйте ILDASM для ее дизассемблирования и замените определение BadMethod на

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

Это превращает его в функцию, возвращающую int32&, которую затем сможет вызвать следующий код. Единственное место, где C# допускает типы int32&, находится в параметрах функции (ref int), поэтому, чтобы сделать результат пригодным для использования, я использовал функцию обратного вызова, которой передается возвращаемое значение BadMethod.

Спасибо "hvd" за то, что указали мне правильное направление. Немного подумав, вот что у меня получилось. Это проще, но, пожалуйста, сообщите мне, если вы видите недостаток.

        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);

Я помещаю простую обертку вокруг вызывающего нарушение метода, и IL не заботится о том, чтобы я рассматривал Byte& как IntPtr. Я все еще не уверен в том, чтобы сделать копию без небезопасной оболочки. Но это пока хорошо.