Question

我正在使用简单的插件架构来控制输入和输出，在C＃中编写程序（目前是3.5，但很可能适应其他需要的版本）。每个插件都是在用户选择要使用的插件时加载的DLL。

由于实际的插件类在运行时才知道，我在包装器类中使用反射来调用方法并访问插件的属性。

到目前为止，我一直在使用以下方法来调用插件上的方法：

public object Method(string methodName, params object[] arguments) {
  // Assumed variables/methods/exceptions:
  //   Dictionary<string, MethodInfo> Methods: a cache of MethodInfo's
  //     of previously called methods.
  //   NoSuchMethodException: thrown if an unknown/unreachable method is
  //     requested. The message member contains the invalid method name
  //   void LoadMethod(string methodName, params object[] arguments): responsible
  //     for retrieving the MethodInfo's, or throw a NoSuchMethodException
  //   object Plugin: an instance of the dynamically loaded class.
  if (!Methods.ContainsKey(methodName)) {
    LoadMethod(methodName, arguments);
  }
  if (arguments != null && arguments.Length == 0) {
    arguments = null;
  }
  return Methods[methodName].Invoke(Plugin, arguments);
}

使用方法如下：

string[] headers = (string[]) Plugin.Method("GetHeaders", dbName, tableName);

这很好用，只要调用者正确地将返回值强制转换为期望值类型。插件必须实现某些接口，因此调用者应该知道这种类型。

然而，在使用反射做了一些进一步的工作后，我发现了以下替代形式：

public T Method<T>(string methodName, params object[] arguments) {
  if (!Methods.ContainsKey(methodName)) {
    LoadMethod(methodName, arguments);
  }
  if (Methods[methodName].ReturnType != typeof(T)) {
    // Could also move this into LoadMethod to keep all the throwing in one place
    throw new NoSuchMethodException(methodName);
  }
  if (arguments != null && arguments.Length == 0) {
    arguments = null;
  }
  return (T) Methods[methodName].Invoke(Plugin, arguments);
}

这个用法如下：

string[] headers = Plugin.Method<string[]>("GetHeaders", dbName, tableName);

此版本实质上将转换移动到Method方法中。调用者显然仍然需要知道预期的返回类型，但情况总是如此。它不适用于void方法，但我可以为其包含一个Method版本：

public void Method(string methodName, params object[] arguments) {
  // Good for void methods, or when you're going to throw away the return
  // value anyway.
  if (!Methods.ContainsKey(methodName)) {
    LoadMethod(methodName, arguments);
  }
  if (arguments != null && arguments.Length == 0) {
    arguments = null;
  }
  Methods[methodName].Invoke(Plugin, arguments);
}

我的问题是 - 其中一个本质上比另一个好（对于'更好'的给定值）？例如，一个明显更快？更容易理解？更支持？

我个人喜欢后者的外观，虽然我有点担心我的返回类型测试（Methods[methodName].ReturnType != typeof(T)）可能过于简单化了。有趣的是，它最初是!(Methods[methodName].ReturnType is T)，但似乎总是失败。

我能找到的最接近的现有问题是Generic method to type casting，并且一些答案表明后一种方法比前者更昂贵，但那里的细节并不多（那里的问题）更倾向于实施该方法而不是更好的方法。

澄清：这是一个手动，非常有限的插件系统，不使用IPlugin。我更感兴趣的是泛型方法本质上是否比预期调用者在这种情况下投射更好/更差。

Answer 1

关于你的问题，我认为你应该同时提供。只需让通用版本调用非泛型版本即可。你可以获得两全其美的效果。关于性能，请考虑与动态调用方法和构建对象数组相比，转换对象所需的时间有多小。在这里考虑性能真的不值得。我从一个风格的角度更喜欢通用方法，但也考虑到你可以在需要时应用类型约束。

public T Method<T>(string methodName, params object[] arguments)
{
    return (T)Method(methodName, arguments);
}

边栏

如果我了解您的设计，我认为您的实现应该转换到预期的界面。如果您知道插件应该支持哪些方法，那么您真的不应该使用反射。

var plugin = (IPlugin)Activator.CreateInstance(pluginType);
var headers = plugin.GetHeaders(dbName, tableName);

你可以尝试一些不同的东西，并要求插件实现一个允许它们注册自定义运行时行为的接口。

public interface IPlugin
{
     void Load(IAppContext context);
     void Unload();
}

您的加载方法可能如下所示。

void LoadPlugins(Assembly a)
{
    var plugins = 
        a.GetTypes()
        .Where(t => typeof(IPlugin).IsAssignableFrom(t))
        .Select(t => (IPlugin)Activator.CreateInstance(t))
        .ToList();
     Plugins.AddRange(plugins);
     foreach (var p in plugins)
     {
         p.Load(Context);
     }
}

C＃通用方法与强制转换

1 个答案: