C# 非常动态的调用

Question

我想用 C# 编写：

SomeUnknownType x;

SuperDuperInvoke(x, "MethodName", param1, param2, param3);

SuperDuperInvoke2(x, "MethodName", "param1String", "param2String", "param3String");

获取一些我一无所知的对象、方法名称和参数列表，然后调用该方法。 SuperDuperInvoke2 假定参数可从字符串转换。

我认为使用动态框架可以实现这样的事情...我只是找不到如何...

我知道我可以使用反射来做到这一点，但它很丑陋且烦人...

---

我会解释一下自己。

我想用它来进行一些业务服务器的集成测试。 服务器有很多不同的组件可以处理请求，所有组件都加载到 IoC 容器中。 我需要公开其中一些组件，主要是为了测试，所以我只想接收组件的名称，我应该使用什么参数调用什么方法，然后调用它。

Answer 1

我知道你写过你不喜欢 Reflection，但这真的那么难看吗？

var result = x.GetType().GetMethod( "MethodName" ).Invoke( x, new object[] { methodParams });

如果该方法可以重载，您不能仅通过名称进行操作，还需要知道要使用多少个参数来调用它。像这样的东西

var method = x.GetType()
              .GetMethods()
              .First(m => m.Name == "MethodName" && m.GetParameters().Length == 2);
var result = method.Invoke( x, new object[] { methodParams });

如果您还需要按类型匹配 methodParams，则这将不起作用。

Answer 2

您说您不喜欢使用反射，但是，由于您提到您只知道方法名称为字符串，因此只有一种方法：反射。这并不像你想象的那么难。这是一种方法：

编辑：更新代码。它现在可以使用重载的成员和任意数量的参数。如果您知道参数的类型，或者参数已正确初始化为其各自的类型，那么这将起作用。

public static object InvokeMethod(object o, string MethodName, object[] parameters)
{
    // get the types of the params
    List<Type> paramTypes = new List<Type>();
    foreach (object p in parameters)
    {
        paramTypes.Add(p.GetType());
    }

    try
    {
        // get the method, equal to the parameter types
        // considering overloading
        MethodInfo methodInfo = o.GetType().GetMethod(MethodName, paramTypes.ToArray());

        // and invoke the method with your parameters
        return methodInfo.Invoke(o, parameters);
    }
    catch (MissingMethodException e)
    {
        // discard or do something
    }
}

---

注意：在您的问题文本中，您提到所有参数都可以转换为字符串，并且您将值作为字符串传递。但是，如果您有像 Calc(int) 和 Calc(long) 这样的方法，并且只有一个字符串值要转换为其中任何一个，那么您将需要更多有关您的方法的信息，因为如果所有参数值都被字符串化，则无法预先知道您应该调用哪些方法。

Answer 3

使用 dynamic 关键字时，您确实需要在编译时知道方法名称，但实际编译后的内容是使用方法名称的字符串常量进行 DLR API 调用。当然可以自己调用这些，但棘手的是 dlr 性能取决于与这些 api 调用一起创建的静态缓存站点。

开源框架 ImpromptuInterface（在 Nuget 中找到）使用一些静态调用方法包装 DLR api 。它对缓存站点进行哈希处理，因此它不如动态关键字快，但它至少比反射快 2 倍。唯一的技巧是，如果您尝试调用需要返回值的 void 返回方法，则会在尝试绑定时引发异常。示例实现：

public static dynamic SuperDuperInvoke(object target, string methodName, params object[] args){
    try{
        return Impromptu.InvokeMember(target, methodName, args);
    }catch(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException){
        Impromptu.InvokeMemberAction(target, methodName, args);
        return null;
    }
}

由于它是开源的（apache 许可证），您可以随时访问 InvokeMember 等的来源，以帮助实现您的 SuperDuperInvoke（如果您不需要依赖项）。

SuperDuperInvoke2 更加困难，因为 DLR 将尝试根据参数类型匹配方法，它将考虑隐式转换，但仅静态定义转换（TryConvert在 DynamicObject 上不起作用），因此您需要一个静态定义的隐式转换为所有预期类型的​​代理，这可能是危险的，请注意方法重载，它们可能会产生歧义SuperDuperInvoke2。

public static dynamic SuperDuperInvoke2(object target, string methodName, params ConvertableProxy[] args){
    return SuperDuperInvoke(target,methodName,args);
}

public class ConvertableProxy{
    private IConvertible _value;
    public ConvertableProxy(IConvertible value){
        _value =value;
    }

    //Automatically convert strings to proxy
    public static implicit operator ConvertableProxy(string value){
        return new ConvertableProxy(value);
    }

    public static implicit operator bool(ConvertableProxy proxy)
    {
        return proxy._value.ToBoolean(null);
    }

    public static implicit operator int(ConvertableProxy proxy)
    {
        return proxy._value.ToInt32(null);
    }

    public static implicit operator string(ConvertableProxy proxy)
    {
        return proxy._value.ToString(null);
    }

    //.. Add Char, DateTime, etc.


}

Answer 4

如果没有动态，您将这样做：

public static SuperDuperInvoke(object o, string methodName, params object parameters)
{
    Type t = o.GetType();
    MethodInfo mi = t.GetMethod(methodName);
    if (mi == null) throw new Exception("no such method: " + methodName);
    mi.invoke(mi, o, parameters.Length == 0 ? null : parameters);
}

现在这是相当幼稚的，因为它不寻找特定的方法。最好的办法是获取该名称的所有方法，并过滤到具有正确数量参数的方法，然后过滤到具有可从给定参数类型分配的类型的方法，然后选择向上转换最少的方法。