Question

我可以轻松地将一个内部方法的调用包装在一个委托中。然后，当我呼叫Invoke()时，代理人可以调用此方法。但是，代表在mscorlib程序集中。为什么它可以从我的程序集中调用内部方法？

显然，委托必须能够为C＃正常工作。问题不在于为什么是允许的。这是如何。

我假设检查可见性是一个C＃功能，直接从CIL调用该方法应该可行。所以我试着从动态定义的类型中调用该方法，因此直接使用CIL并跳过C＃。它悲惨地失败了。这是代码：

public static class InternalCall
{
    internal static void InternalMethod()
    {
        Debug.WriteLine("Successfully called an internal method from: " + typeof(InternalCall).Assembly.FullName);
    }

    public interface IMyAction
    {
        void MyInvoke();
    }

    private static IMyAction MakeMyAction()
    {
        var assembly = Thread.GetDomain().DefineDynamicAssembly(new AssemblyName("Outside"), AssemblyBuilderAccess.Run);
        var module = assembly.DefineDynamicModule("Outside", false);
        var customType = module.DefineType("MyAction",
            TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
            typeof(object),
            new[] { typeof(IMyAction) });
        var method = customType.DefineMethod("MyInvoke",
            MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final);
        var il = method.GetILGenerator();
        il.Emit(OpCodes.Call, typeof(InternalCall).GetMethod("InternalMethod", BindingFlags.Static | BindingFlags.NonPublic));
        il.Emit(OpCodes.Ret);

        return (IMyAction)customType.CreateType().GetConstructor(Type.EmptyTypes).Invoke(null);
    }

    public static void RunTest()
    {
        var action = new Action(InternalMethod);
        Debug.WriteLine("Calling via action from assembly: " + action.GetType().Assembly.FullName);
        action.Invoke();

        var myAction = MakeMyAction();
        Debug.WriteLine("Calling via my type from assembly: " + myAction.GetType().Assembly.FullName);
        myAction.MyInvoke(); // MethodAccessException
    }
}

因此，假设代表仍然遵守CIL规则（因为这是C＃编译的规则），他们使用什么CIL机制来调用任何方法而不管可见性？

Answer 1

了解自定义委托在CIL中的外观是很有见地的：

.class auto ansi sealed MyDeleg extends [mscorlib]System.MulticastDelegate
{

.method public hidebysig specialname rtspecialname instance void .ctor(object 'object', native int 'method') runtime managed
{
}

.method public hidebysig newslot virtual instance class [mscorlib]System.IAsyncResult BeginInvoke(class [mscorlib]System.AsyncCallback callback, object 'object') runtime managed
{
}

.method public hidebysig newslot virtual instance int32  EndInvoke(class [mscorlib]System.IAsyncResult result) runtime managed
{
}

.method public hidebysig newslot virtual instance int32  Invoke() runtime managed
{
}

}

就是这样。 runtime属性告诉我们，运行时提供了此方法的实现，而不是代码（cil）。这就像p / invoke到运行时。在这个阶段，没有代码检查，没有验证者，没有JIT。执行被处理到CLR以决定如何调用委托，然后只是调用委托。

执行类似于calli指令，但这并不是这些方法的实现方式，尽管您可以使用它来很好地模拟委托。为什么没有能见度检查？因为它是传递给指令的原始方法指针（来自 GetFunctionPointer ），并且获取其元数据可能会导致负面的性能影响（或者可能根本没有元数据）。当然，进行任何可见性检查都是不可取的。

Answer 2

我想我找到了代表背后的基本机制。以前应该发生在我身上。他们使用间接调用，即CIL中的var toCallInfo = typeof(InternalCall).GetMethod("InternalMethod", BindingFlags.Static | BindingFlags.NonPublic); unsafe { var functionPointer = toCallInfo.MethodHandle.GetFunctionPointer(); if (sizeof(IntPtr) == 4) il.Emit(OpCodes.Ldc_I4, (int)functionPointer); else il.Emit(OpCodes.Ldc_I8, (long)functionPointer); } il.EmitCalli(OpCodes.Calli, toCallInfo.CallingConvention, null, null, null); il.Emit(OpCodes.Ret);指令，它似乎不会进行可见性检查。

我仍然不确定它们存储的确切内容以及它们的执行方式，但我很满意将方法的函数指针硬编码到我发出的CIL中可以使其工作，因此它说明了原理。

{{1}}

现在创建类型并运行它并不会引发异常。

为什么委托对象可以调用内部方法？

2 个答案: