如何在 C# 中从字符串调用委托？

Question

是否可以通过变量名称（作为字符串）调用存储在变量中的委托？我想我必须使用反射机制，但我没有得到任何结果

示例代码：

class Demo {
  public delegate int DemoDelegate();

  private static int One() {
    return 1;
  }

  private static void CallDelegate(string name) {
    // somehow get the value of the variable with the name
    // stored in "name" and call the delegate using reflection
  }

  private static void CallDelegate(string name, DemoDelegate d) {
    d();
  }

  static void main(string[] args) {
    DemoDelegate one = Demo.One;
    CallDelegate(one);
    // this works, but I want to avoid writing the name of the variable/delegate twice:
    CallDelegate("one", one);
  }

}

这可能吗？如果是这样怎么办？

Answer 1

变量几乎不存在。可靠地按字符串调用（在这种情况下）的唯一方法是将委托存储在字典中：

Dictionary<string, DemoDelegate> calls = new Dictionary<string, DemoDelegate>
{
    {"one",one}, {"two",two}
}

现在将该字典存储在某处（在字段中，通常），并执行以下操作：

private int CallDelegate(string name) {
    return calls[name].Invoke(); // <==== args there if needed
}

Answer 2

是的，这是可能的，只要你使用 Linq 表达式，并且很少进行反射。

看看这段代码，它的功能与我认为您想要的类似：

using System;
using System.Linq.Expressions;
using System.Reflection;
using System.Collections.Generic;

namespace q6010555
{
    class Demo
    {
        static List<string> varNamesUsed = new List<string>();

        public delegate int DemoDelegate();

        private static int One()
        {
            return 1;
        }
        private static void CallDelegate(Expression<Func<DemoDelegate>> expr)
        {
            var lambda = expr as LambdaExpression;
            var body = lambda.Body;
            var field = body as MemberExpression;
            var name = field.Member.Name;
            var constant = field.Expression as ConstantExpression;
            var value = (DemoDelegate)((field.Member as FieldInfo).GetValue(constant.Value));

            // now you have the variable name... you may use it somehow!
            // You could log the variable name.
            varNamesUsed.Add(name);

            value();
        }
        static void Main(string[] args)
        {
            DemoDelegate one = Demo.One;
            CallDelegate(() => one);

            // show used variable names
            foreach (var item in varNamesUsed)
                Console.WriteLine(item);
            Console.ReadKey();
        }
    }
}

Answer 3

您无法真正访问另一个堆栈框架中的变量（尽管我认为可以在 StackFrame 类周围使用黑客技术）。相反，如果您想以类似反射的方式调用通用委托，则需要传递 Delegate 对象并使用 DynamicInvoke 等方法。

Answer 4

public void Fire(string name)
        {
            FieldInfo field = this.GetType().GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            if (field != null)
            {
                Delegate method = field.GetValue(this) as Delegate;

                if (method != null)
                {
                    method.Method.Invoke(method.Target, new object[0]);
                }
            }
        }

显然限制您拥有参数化委托。

Answer 5

我不记得十多年前我想实现什么目标，但现在读到这个问题，我想提出一个潜在的解决方法。该解决方法并不能完全避免重复，但它摆脱了手动字符串化变量名称的情况。

nameof 表达式 允许生成变量、类型或成员的名称。

static void main(string[] args) {
  DemoDelegate one = Demo.One;
  CallDelegate(one);
  CallDelegate(nameof(one), one);
}

标识符仍然重复，但至少现在使用重构工具更改变量的名称也会更改用于日志记录的名称。现在不可能忘记更新日志记录中使用的名称，因为这会导致编译错误（“未知标识符”）。