c#泛型方法vs类型转换

本文关键字：类型转换 vs 泛型方法 | 更新日期: 2023-09-27 18:10:31

我正在用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)，但似乎总是失败。

我能找到的与此最接近的问题是泛型方法到类型转换，一些答案表明后一种方法比前者更昂贵，但没有太多细节(问题更多地是关于方法的实现，而不是哪个更好)。

澄清:这是一个手工制作的，非常有限的插件系统，没有使用IPlugin。我更感兴趣的问题是，在这种情况下，与期望调用者进行类型转换相比，泛型方法是否本质上更好/更差。

c#泛型方法vs类型转换

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

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);
     }
}
相关文章：