如何声明一个可以采用直到运行时才知道的枚举的委托？

Question

我有一个客户端应用程序，它使用外部 dll 中的类（和枚举），该 dll 在运行时加载并反映。我知道我期望在 dll 中找到哪些方法以及我期望调用它的枚举。

我想创建一个可以在客户端应用程序中使用的委托，它是在运行时从反射方法创建的。这种方法在委托只有“标准”类型时有效，但是如果 dll 方法采用枚举，我怎样才能让它工作呢？我不能将委托中的枚举声明为object，因为它是一种值类型，尝试Enum 或int 似乎也不起作用。有没有解决的办法？感谢您的帮助！

// e.g. external code
namespace test2 
{
    public static class test2
    {
        public static int calc(int a, int b, testEnum c)
        {
            if (c == testEnum.add) return a + b;
            else return a - b;
        }

        public static int add(int a, int b)
        {
            return a + b;
        }
    }

    public enum testEnum
    {
        add, subtract
    }
}

// my client code
namespace test1
{
    public class TestClient
    {
        private static Assembly _assembly;

        public static void SetUp()
        {
            const string externalDll = ".../test2.dll";

            Assembly assembly = Assembly.LoadFrom(externalDll);
            AppDomain.CurrentDomain.Load(assembly.GetName());
            _assembly = assembly;
        }

        private delegate int _add(int a, int b);
        private _add add;

        private delegate int _calc(int a, int b, ??? c); // nothing works here
        private _calc calc;

        public void Run()
        {
            SetUp();
            add = GetExpectedFunction<_add>("add");
            int three = add(1, 2); // OK

            calc = GetExpectedFunction<_calc>("calc"); // not OK

            // intended usage
            var reflectedEnum = ReflectMe("testEnum", "add");
            int threeAgain = calc(1, 2, reflectedEnum); 
        }

        public static T GetExpectedFunction<T>(string functionName) where T : class
        {
            try
            {
                if (!typeof(T).IsSubclassOf(typeof(Delegate))) throw new ApplicationException("GetExpectedFunction must return a delegate!");
                var foundMethod = _assembly.GetType("test2.test2").GetMethod(functionName, BindingFlags.Public | BindingFlags.Static);
                return (T)(object)Delegate.CreateDelegate(typeof(T), foundMethod);  
            }
            catch (Exception e)
            {
                // "Error binding to target method!"
            }
        }
    }
}

Answer 1

您可以将 object 类型的委托绑定到采用 enum 的方法，方法是在运行时使用 LINQ Expression 创建动态方法调用，并为类型不匹配的参数添加数据转换：

public static T GetExpectedFunction<T>(string functionName) where T : class {
    try {
        if (!typeof(T).IsSubclassOf(typeof(Delegate))) throw new ApplicationException("GetExpectedFunction must return a delegate!");
        var foundMethod = Type.GetType("test2.test2").GetMethod(functionName, BindingFlags.Public | BindingFlags.Static);
        var inv = typeof(T).GetMethod("Invoke");
        var parameters = inv.GetParameters().Zip(foundMethod.GetParameters(), (a, b) => new {
            PassedIn = a.ParameterType
        ,   Reflected = b.ParameterType
        ,   Parameter = Expression.Parameter(a.ParameterType)
        }).ToList();
        if (parameters.All(p => p.PassedIn == p.Reflected)) {
            // Bind directly
            return (T)(object)Delegate.CreateDelegate(typeof(T), foundMethod);  
        }
        var call = Expression.Call(foundMethod, parameters.Select(
            p => p.PassedIn==p.Reflected
        ?   (Expression)p.Parameter
        :   Expression.Convert(p.Parameter, p.Reflected)
        ));
        return (T) (object) Expression.Lambda(typeof(T), call, parameters.Select(p => p.Parameter)).Compile();
    } catch (Exception e) {
        // "Error binding to target method!"
        return null;
    }
}

此实现将反射方法和委托方法中的类型配对（请参阅parameters 变量），并为来自委托的类型创建ParameterExpression 对象。然后它检查所有参数类型是否匹配（parameters.All(...) 部分）。这是针对不需要转换的情况的优化。

如果至少需要进行一次转换，代码会创建一个方法调用，将原始参数表达式替换为类型不匹配的转换表达式，创建请求的委托类型的 lambda，对其进行编译，然后将其返回给来电者。

对于您的代码，此动态方法如下所示：

int dynamic_method(int a, int b, object c) {
    return test2.test2(a, b, (testEnum)c);
}

Answer 2

有一种解决方案，你必须创建伪造的枚举（如果你创建精确的枚举会更好），然后你会像这样传递整数：

   private delegate int _add(int a, int b);
    private _add add;

    private delegate int _calc(int a, int b, FakedEnum c); // faked enum here
    private _calc calc;

    public enum FakedEnum
    {

    }

    public void Run()
    {
        SetUp();
        add = GetExpectedFunction<_add>("add");
        int three = add(1, 2); // OK

        calc = GetExpectedFunction<_calc>("calc"); // it will be ok
    var result=    calc(4, 6, (FakedEnum)0);
        // intended usage
       // var reflectedEnum = ReflectMe("testEnum", "add");
        //int threeAgain = calc(1, 2, reflectedEnum);
    }

Answer 3

使用 dynamic 关键字来声明你的委托参数：

private delegate int _calc(int a, int b, dynamic c);