IL Вызов метода с двумя аргументами массива с использованием Reflection.Emit - PullRequest
Новая
       47

IL Вызов метода с двумя аргументами массива с использованием Reflection.Emit

4 голосов
/ 13 декабря 2011

Сначала я должен извиниться за то, что был нубом с ИЛ. У меня возникают трудности при создании кода IL для вызова метода с такой подписью: 

public void CallMethod2(string name, object[] args, object[] genericArgs)

Я могу вызвать метод с одним массивом, который выглядит следующим образом: 

public void CallMethod1(string name, object[] args)

с использованием следующих работ IL: 

ILGenerator ilgen = myMethod.GetILGenerator();
var il = ilgen;
MethodInfo invokerMethod = typeof(Proxy<T>).GetMethod("CallMethod1", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, method.Name);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Newarr, typeof(System.Object));
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stelem_Ref);
il.Emit(OpCodes.Ldloc_0);

il.Emit(OpCodes.Call, invokerMethod);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ret);

Но затем я использую следующий IL, чтобы попытаться вызвать CallMethod2, используя этот IL: 

ILGenerator ilgen = myMethod.GetILGenerator();
var il = ilgen;
MethodInfo invokerMethod = typeof(Proxy<T>).GetMethod("CallMethod2", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, method.Name);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Newarr, typeof(System.Object));
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stelem_Ref);

il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Newarr, typeof(System.Object));
il.Emit(OpCodes.Stloc_1);
il.Emit(OpCodes.Ldloc_1);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stelem_Ref);

il.Emit(OpCodes.Ldloc_1);
il.Emit(OpCodes.Ldloc_2);

il.Emit(OpCodes.Call, invokerMethod);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ret);

Это IL с дополнительным объектом [] Я получаю сообщение об ошибке:

Common Language Runtime обнаружил недопустимую программу.

Как вы можете видеть, все, что я сделал, добавило 2-й блок для заполнения массива и вызова метода, похоже, что при использовании StLoc_1 он просто повреждает его.

Я написал тот же метод и нормально его вызвал, посмотрел на ILDasm и коды, кажется, все связаны.

Спасибо

Ответы [ 3 ]

4 голосов
/ 13 декабря 2011

Я очень запутался ... вы видите: этот код не должен работать , так как вы фактически не выделяли никаких местных жителей; например, вот плохо написанный (в том смысле, что он использует ненужные локальные) метод умножения на 4, который не объявляет локальные: 

    var method = new DynamicMethod("MulBy4", typeof (int),
         new Type[] {typeof (int)});
    var il = method.GetILGenerator();
    il.Emit(OpCodes.Ldc_I4_4);
    il.Emit(OpCodes.Stloc_0); // this usage is 
    il.Emit(OpCodes.Ldloc_0); // deliberately silly
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Mul);
    il.Emit(OpCodes.Stloc_1); // this usage is 
    il.Emit(OpCodes.Ldloc_1); // deliberately silly
    il.Emit(OpCodes.Ret);
    var mulBy4= (Func<int,int>)method.CreateDelegate(typeof (Func<int, int>));
    var twelve = mulBy4(3);

Это создает VerificationException:

Операция может дестабилизировать время выполнения.

, поскольку это невозможно проверить. Это плохо, ИЛ! Если мы изменим его на: 

    var method = new DynamicMethod("MulBy4", typeof (int),
         new Type[] {typeof (int)});
    var il = method.GetILGenerator();
    il.DeclareLocal(typeof (int));
    il.DeclareLocal(typeof(int));
    ...

тогда сейчас все работает. Это затем приводит к альтернативе запоминанию чисел - путем сохранения и использования LocalBuilder, который возвращается из DeclareLocal: 

    var method = new DynamicMethod("MulBy4", typeof (int),
         new Type[] {typeof (int)});
    var il = method.GetILGenerator();
    var multiplier = il.DeclareLocal(typeof (int));
    var result = il.DeclareLocal(typeof(int));
    il.Emit(OpCodes.Ldc_I4_4);
    il.Emit(OpCodes.Stloc, multiplier);
    il.Emit(OpCodes.Ldloc, multiplier);
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Mul);
    il.Emit(OpCodes.Stloc, result);
    il.Emit(OpCodes.Ldloc, result);
    il.Emit(OpCodes.Ret);
    var mulBy4= (Func<int,int>)method.CreateDelegate(typeof (Func<int, int>));
    var twelve = mulBy4(3);

Если вы обеспокоены тем, что здесь используется более длинная версия IL, вы можете использовать вместо этого: 

static void LoadLocal(this ILGenerator il, LocalBuilder local)
{
    switch(local.LocalIndex)
    {
        case 0: il.Emit(OpCodes.Ldloc_0); break;
        case 1: il.Emit(OpCodes.Ldloc_1); break;
        case 2: il.Emit(OpCodes.Ldloc_2); break;
        case 3: il.Emit(OpCodes.Ldloc_3); break;
        default:
            if(local.LocalIndex < 256)
            {
                il.Emit(OpCodes.Ldloc_S, (byte) local.LocalIndex);
            } else
            {
                il.Emit(OpCodes.Ldloc, (ushort) local.LocalIndex);
            }
            break;
    }
}

вместе с il.LoadLocal(multiplier); и il.LoadLocal(result); (и, очевидно, что-то похожее для Stloc)

4 голосов
/ 13 декабря 2011

Я думаю, проблема в том, что эти строки перед вызовом метода: 

il.Emit(OpCodes.Ldloc_1);
il.Emit(OpCodes.Ldloc_2);

должны быть 

il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldloc_1);

Ваши массивы находятся в позициях стека 0 и 1, а не 1 и2.

0 голосов
/ 13 августа 2018

Я обновил ответ @ Mark, чтобы также охватить типы значений. StoreLocal это бонус:) 

public static void LoadLocalValue(this ILGenerator il, LocalBuilder local)
{
    switch (local.LocalIndex)
    {
        case 0: il.Emit(OpCodes.Ldloc_0); break;
        case 1: il.Emit(OpCodes.Ldloc_1); break;
        case 2: il.Emit(OpCodes.Ldloc_2); break;
        case 3: il.Emit(OpCodes.Ldloc_3); break;
        default:
            if (local.LocalIndex < 256)
            {
                il.Emit(OpCodes.Ldloc_S, (byte)local.LocalIndex);
            }
            else
            {
                il.Emit(OpCodes.Ldloc, (ushort)local.LocalIndex);
            }
            break;
    }
}

public static void LoadLocalAddress(this ILGenerator il, LocalBuilder local)
{
    if (local.LocalIndex < 256)
    {
        il.Emit(OpCodes.Ldloca_S, (byte)local.LocalIndex);
    }
    else
    {
        il.Emit(OpCodes.Ldloca, local);
    }
}

public static void LoadLocalAuto(this ILGenerator il, LocalBuilder local)
{
    if (local.LocalType?.IsValueType == true)
    {
        LoadLocalAddress(il, local);
        return;
    }
    LoadLocalValue(il, local);
}

public static void StoreLocal(this ILGenerator il, LocalBuilder local)
{
    switch (local.LocalIndex)
    {
        case 0: il.Emit(OpCodes.Stloc_0); break;
        case 1: il.Emit(OpCodes.Stloc_1); break;
        case 2: il.Emit(OpCodes.Stloc_2); break;
        case 3: il.Emit(OpCodes.Stloc_3); break;
        default:
            if (local.LocalIndex < 256)
            {
                il.Emit(OpCodes.Stloc_S, (byte)local.LocalIndex);
            }
            else
            {
                il.Emit(OpCodes.Stloc, (ushort)local.LocalIndex);
            }
            break;
    }
}
...