C# 泛型方法与转换

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);

只要调用者正确地将返回值转换为预期的值，它就可以很好地工作类型。插件必须实现某些接口(interface)，因此调用者应该知道这种类型。

然而，在对反射做了一些进一步的工作之后，我想到了以下替代形式:

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 方法，但我可以为此包含一个方法版本:

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);

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

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);
     }
}