C# 中反射的高效使用

Question

我正在用 C# 编写一个库，稍后将其用于应用程序，并且我希望该库尽可能高效（即不要使事情过于复杂以使其更高效）。但是，我有一个关于如何最有效地使用类/方法上的反射的问题，并说明我已经将我的类简化了很多的问题：

class MyClass
{
    private static Dictionary<string, object> methods;

    public void Method1()
    {
        // Do something.
    }

    public void Method2()
    {
        // Do something else.
    }
}

现在，我想要的是来自类内部的（一个私有方法）来创建），获取一个包含方法名称的字符串，然后触发该方法，就这么简单。最简单的方法是只查看名称，获取具有该名称的方法，然后执行它，但这迫使我多次使用反射。这个私有方法可能会被调用数千或数万次，并且需要很快。所以我想出了两种可能的解决方案。正如您可能看到的那样，我添加了一个包含 string->object 的静态字典（用实际类型替换对象，只是编写了适用于我的两个示例的对象原因）。然后我添加一个静态构造函数，该构造函数遍历类并将所有方法信息添加到方法字典中。然后出现的问题是，在创建类的新实例时，我应该创建方法的绑定委托并将其放入非静态私有字典中，还是应该简单地使用方法字典中的 MethodInfo 来触发方法？

平均用例将创建此类的 10 个实例，并且对方法进行 1000 多次调用，这些方法应该根据其字符串参数触发 Method1 或 Method2（不，switch-case 不是一个选项，因为类，正如所说，这是一个简化版本）。实现这一目标最有效的方法是什么？

Answer 1

显然，如果没有实际尝试并进行性能测试来看看您的目标是否达到，没有人可以回答这个问题。

在框架的现代版本中，反射比以前快得多，但它仍然不如简单调用委托那么快。

我的建议是从您提出的解决方案开始：构建方法信息的缓存一次：

class MyClass
{
    static Dictionary<string, MethodInfo> cache = new ...
    public void InvokeByName(string name)
    {
        MethodInfo methodInfo = GetMethodInfoFromCache(name);
        methodInfo.Invoke(this, new object[] {});
    }

当被要求调用由特定实例上的字符串标识为接收者的方法时，按名称查找方法信息，然后使用给定的接收者。衡量其性能，看看它是否满足您的目标。如果是的话，那就太好了；不要再浪费宝贵的时间试图让已经足够快的东西变得更快。

如果这还不够快，那么我会这样做：

class MyClass
{
    static Dictionary<string, Action<MyClass>> cache = new ...
    public void InvokeByName(string name)
    {
        GetActionFromCache(name).Invoke(this);            
    }

那么 GetActionFromCache 是做什么的？如果缓存中已经有一个操作，那么我们就完成了。如果没有，则通过Reflection获取MethodInfo。然后使用表达式树库构建 Lambda：

var methodInfo = SomehowGetTheMethodInfo(name);
// We're going to build the lambda (MyType p)=>p.<named method here>()    
var p = Expression.Parameter(typeof(MyType), "p"));
var call = Expression.Call(p, methodInfo);
var lambda = Expression.Lambda<Action<MyType>>(call, p);
var action = lambda.Compile();

现在您手头有一个可以使用实例调用的操作。把那个东西放在缓存里。

顺便说一句，这就是 C# 4 中“动态”工作方式的极其简化的程度。我们的问题非常复杂，因为我们必须处理 任何 类型的接收者和参数。相对来说你很容易。

Answer 2

因为您将获得所有 MethodInfo 实例以及将它们映射到的名称（大概通过 MethodInfo.Name 属性，您可以更进一步，以委托的形式创建一个可以执行的已编译 lambda 表达式

。您的所有方法都将具有相同的签名，在这种情况下，它是 Action delegate 这样，您的字典将如下所示：

// No need to have the dictionary **not** readonly
private static readonly IDictionary<string, Action<MyClass>> methods =
    new Dictionary<string, Action<MyClass>>;

然后，在静态构造函数中，您将使用反射来获取所有 < code>MethodInfo 实例：

static MyClass()
{
    // Cycle through all the public instance methods.
    // Should filter down to make sure signatures match.
    foreach (MethodInfo methodInfo in typeof(MyClass).
        GetMethods(BindingFlags.Public | BindingFlags.Instance))
    {
        // Create the parameter expression.
        ParameterExpression parameter = Expression.
            Parameter(typeof(MyClass), "mc");

        // Call the method.
        MethodCallExpression body = Expression.Call(pe, methodInfo);

        // Compile into a lambda.
        Action<MyClass> action = Expression.Lambda<Action<MyClass>>(
            body, parameter).Compile();

        // Add to the dictionary.
        methods.Add(methodInfo.Name, action);
    }
}

然后，您的私有方法将如下所示：

private void ExecuteMethod(string method)
{
    // Add error handling.
    methods[method]();
}

这里的好处是您可以获得编译代码的性能，同时在代码复杂性（创建委托时）上付出很小的代价（IMO） 。诚然，通过委托调用代码会产生一点开销，但这已经得到了很大的改进（这必须通过引入 LINQ 来实现，因为它们会被执行很多很多次）。

Answer 3

如果我可以选择，我可能会采纳 Henk 的建议并使用动态。方法调用速度非常快（比普通反射快得多，几乎与普通方法调用一样）。

您还可以通过查看此类< /a>，它扩展了 DynamicObject 并说明了如何动态调用方法。

但是，如果您希望支持 3.5 或保持选择余地，并且不反对使用第 3 方库，那么这仍然可以相当容易地完成：

void Invoke( string methodName )
{
    this.CallMethod( methodName );
}

CallMethod 创建一个 DynamicMethod 委托来调用该特定方法并缓存它，以防您再次调用相同的方法。还有用于调用带有参数的方法的扩展以及大量其他有用的反射助手。

如果您更喜欢自己缓存委托（我们使用 ConcurrentDictionary 和 WeakReferences 来执行此操作，这意味着它可能会被垃圾收集），只需调用 DelegateForCallMethod 即可。

该库支持 3.5 和 4.0。 WP7 不支持 Reflection.Emit，因此无法使用 IL 生成和 DynamicMethod。但是，WP 7.5 确实支持此功能（但该库的名称为 Fasterflect，尚不支持）。

Answer 4

从你的评论来看：

<块引用>

嗯，简单来说就是连接到一个服务器，服务器以的形式发送命令。 <参数1> <参数2> ...，名称决定应执行什么功能。我希望能够添加具有匹配名称的函数（或者更确切地说，我创建了一个属性，可以让我命名除方法名称之外的方法，因为命令名称可能是数字），因为名称列表太长了，而且我不想做 switch-case。

您可以使用简单的命令界面和匹配实例（或类型，如果命令实例不可重用）的表驱动工厂来解决此问题。

public interface ICommand {
  void Execute();
}

public class Processor {
  private static Dictionary<string, ICommand> commands;
  static Processor() {
    // create and populate the table
  }
  public void ExecuteCommand(string name) {
    // some validation...
    commands[name].Execute();
  }
}

不涉及反射。

要创建新命令，只需创建一个实现 ICommand 的新类，并将相应的行添加到 Processor 静态构造函数内的 commands 表中。

public class FooCommand : ICommand {
  public void Execute() {
    // foo away!
  }
}

...

public class Processor {
  static Processor() {
    ...
    commands["foo"] = new FooCommand();
    ...
  }
}

除了性能之外，这种设计还有很多优点。您的命令是相互隔离的，对一个命令的更改或创建新命令不会影响其他命令。它们更易于测试且更易于维护。如果您可以将表维护为例如，配置文件或数据库。

您当然可以找到替代设计和将参数传递给命令的方法，但我希望这能给您基本的想法。

Answer 5

在这种特殊情况下，您可以稍微不同地声明您的字典并获得您想要的结果：：

class MyClass
{
    private static Dictionary<string, Action<MyClass>> methods;

    public void Method1()
    {
        // Do something.
    }

    public void Method2()
    {
        // Do something else.
    }
    static MyClass(){
       methods = new Dictionary<string, Action<MyClass>>();
       foreach(var method in typeof(MyClass).GetMethods(
               BindingFlags.Public | BindingFlags.Instance)
       )
        {
            methods.Add(
                method.Name,
                Delegate.CreateDelegate(typeof(Action<MyClass>),method) 
                  as Action<MyClass>);
        }
    }
}

此代码的优点是不使用代码生成。但是，如果您有不同签名的方法，则需要不同的方法。在这里，我们正在创建开放实例委托。 （请注意，如果 MyClass 是结构体或者这些方法中的任何一个是通用虚拟方法，则这并不总是能正常工作）。

Answer 6

做某事最快的方法就是根本不做。您是否考虑过制作这样的接口：

interface ICallMe 
{
 void CallByName(string name, object args);
}

这样，如果某些实现想要变得非常智能，它可以进行反射+缓存+IL生成，其他实现可以简单地使用if/switch。

缺点 - 实施和调试的乐趣明显减少。

Answer 7

调用 MethodInfo 速度很慢。所以我认为为每个实例创建一个新字典应该足够好了。另一种选择是使用表达式创建接受实例 (Action) 的委托（然后将它们存储在静态字典中）：

MethodInfo method = typeof(MyClass).GetMethod("Method1");

var parameter = Expression.Parameter(typeof(MyClass));

var call = Expression.Call(parameter, method);

var lambda = Expression.Lambda<Action<MyClass>>(call, parameter);

Action<MyClass> del = lambda.Compile();

Answer 8

您是否考虑过使用代码生成和 T4 文本模板？

http://msdn.microsoft.com/en-us/library/bb126445.aspx
http://msdn.microsoft.com/en-us/library/bb126478.aspx

然后你可以使用 case 语句。

像这样的东西

partial Class MyClass
{
    public void Exec(string funcToExec)
    {
        swtich(funcToExec)
        {
            <#
            foreach(MethodInfo mi in 
                typeof(MyClass).GetMethods(BindingFlags.Public | BindingFlags.Static)
            { 
                if(mi.Name != "Exec"){
            #>
            case : "<#= mi.Name #>"
                <#= mi.Name #>();
            <#
            }}
            #>
        }
    }
}