无法在仅反射的上下文中获取MethodInfo实例

Question

The following code shows method's name correctly:

static void Main(string[] args)
{
    try
    {
        Assembly assembly = Assembly.Load("ClassLibrary1");
        foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
        {
            Assembly.Load(referencedAssembly.Name);
        }
        Type bl1Type = assembly.GetType("ClassLibrary1.Bl1");
        var types = new[] {typeof(MyEnum) };
        var method = bl1Type.GetMethod("Method1", BindingFlags.Instance | BindingFlags.Public, Type.DefaultBinder, types, null);
        Console.WriteLine(method == null ? "Method was null" : $"Found {method.Name}");
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        throw;
    }
}

But if I try to resolve Method1 in a reflection-only context to improve performance and change the call to Assembly.Load("ClassLibrary1"); with Assembly.ReflectionOnlyLoad("ClassLibrary1"); then method is always null and don't get resolved. Any ideas about how to resolve a method in a reflection-only context?

Answer 1

If you try the following you will see that your method is found in the list

var methods = bl1Type.GetMethods(BindingFlags.Instance | BindingFlags.Public);

Also,if you search for the method that accepts the string parameter it will also work

var types = new[] {typeof(string)};

I think it's confused by the MyEnum.
If you load the MyEnum from the second dll it will work

Assembly assembly2 = Assembly.ReflectionOnlyLoad("ClassLibrary2");
Type bl2Type = assembly2.GetType("ClassLibrary2.MyEnum");
var types = new[] { bl2Type };

The full code

using System;
using System.Linq;
using System.Reflection;

namespace ReflectionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly assembly = Assembly.ReflectionOnlyLoad("ClassLibrary1");
            Type bl1Type = assembly.GetType("ClassLibrary1.Bl1");
            var types = new[] { Assembly.ReflectionOnlyLoad(assembly.GetReferencedAssemblies().Single(a => a.Name == "ClassLibrary2").Name).GetType("ClassLibrary2.MyEnum") };
            //var types = new[] {typeof(MyEnum)}; //doesn't work
            var method = bl1Type.GetMethod("Method1", BindingFlags.Instance | BindingFlags.Public, Type.DefaultBinder, types, null);
            Console.WriteLine(method == null ? "Method was null" : $"Found {method.Name}");
            Console.ReadLine();
        }
    }
}

So,your initial code doesn't work because it tries to find a method that uses a different "MyEnum" (and of course it doesn't exist)

Answer 2

ReflectionOnly context is separate loader context from the regular loader context. It loads own copy of the assemblies and types, the system types from mscorlib are shared with the regular loader context though.

Also, there is typically no performance advantage in loading assemblies into ReflectionOnly context. ReflectionOnly context uses the exact same loading mechanism as regular assemblies, except that attempt to execute any code from them is blocked and a few sanity checks are suppressed ( https://blogs.msdn.microsoft.com/junfeng/2004/08/24/reflection-only-assembly-loading/ describes the details).