为字符串调用适当的方法

为什么不将它们"映射"到"命令"类一次，而且只有一次呢？

例如

[OnConsume:RestoreHealth(15)]
[OnConsume:RestoreFatigue(15)]

可以映射到RestoreHealth和RestoreFatigue命令类，这些命令类可以定义为：

public sealed class RestoreHealth : ICommand {
    public int Value { get; set; }
    //whatever else you need
}
public sealed class SummonMonster : ICommand {
    public int Count {get; set; }
    public Position Position { get; set; }
}

此时，将命令视为参数的包装器;)因此，您始终包装它们并仅传递一个参数，而不是传递多个参数。它还提供了一些语义。

现在，您可以将库存物品映射到在使用每个物品时需要"发送"的命令。

您可以实现一个简单的"总线"接口，例如：

public interface IBus {
    void Send(ICommand command);
    void Subscribe(object subscriber);
}

现在，您只需获得IBus的实例，并在适当的时候调用其Send方法。

通过这样做，您将您的"定义"（需要做什么）和逻辑（如何执行操作）问题分开。

对于接收和反应部分，您实现Subscribe方法来询问subscriber实例（再次，一次且仅一次），找出其所有可以"处理"命令的方法。您可以在处理程序中提出一些IHandle<T> where T: ICommand接口，或者只是按照约定（任何只接受一个ICommand参数并返回void的Handle方法）或任何适合您的方法。

它基本上与您所说的"委托/操作"列表的相同部分，只是现在它是每个命令：

map<CommandType, List<action>>

由于所有操作现在只接受一个参数（即ICommand），因此您可以轻松地将它们全部保留在同一列表中。

收到某些命令时，IBus实现仅获取给定命令类型的操作列表，并简单地调用这些操作，将给定命令作为参数传递。

希望对您有所帮助。

高级：您可以更进一步：有一个ConsumeItem命令：

public sealed void ConsumeItem: ICommand {
    public InventoryItem Item { get; set; }
}

您已经有一个负责保存 InventoryItem 和 Command 之间的映射的类，因此此类可以成为进程管理器：

1. 它订阅ConsumeItem命令（通过总线）
2. 在其Handle方法中，它获取给定库存项的命令列表
3. 它将这些命令发送到总线。

好了，现在我们已经清楚地区分了这三个问题：

1. 在使用库存物品时，我们只是"知道"IBus并发送ConsumeItem命令，我们不关心接下来会发生什么。
2. "ConsumptionInventoryManager"（不管你怎么称呼它）也知道IBus', subscribes for ConsumptionItem'命令，并"知道"当每个项目被消耗时需要做什么（命令列表）。它只是发送这些命令，并不关心谁以及如何处理它们。
3. 业务逻辑（角色、怪物等）只处理对它们有意义的命令（RestoreHealth、Die等），而不关心它们来自哪里（以及为什么）。

祝你好运:)

我的建议是使用反射，即定义一个基于指定名称调用所需方法的方法。下面是一个工作示例：

class Program
{
    static void Main(string[] args)
    {
        SomeClass someInstance = new SomeClass();
        string name = Console.ReadLine();
        someInstance.Call("SayHello", name);
    }
}
class SomeClass
{
    public void SayHello(string name)
    {
        Console.WriteLine(String.Format("Hello, {0}!", name));
    }
    public void Call(string methodName, params object[] args)
    {
        this.GetType().GetMethod(methodName).Invoke(this, args);
    }
}

只要满足以下条件，您就可以这样做：

1. 您绝对确定可以调用，即存在指定名称的方法，并且参数的数量和类型是正确的

2. 指定名称的方法不重载，否则会得到System.Reflection.AmbiguousMatchException

存在一个超类，要

3. 在其上使用 Call 方法的所有类都派生自该超类;您应该在该类中定义此方法

确保*条件 1. 和 2. 满意 您可以使用更具体的Type.GetMethod版本，它不仅考虑方法的名称，还考虑参数的数量和类型，并在调用之前检查是否存在这样的方法; 然后Call方法将如下所示（*它不适用于参数标记为out或ref的方法）：

public void Call(string methodName, params object[] args)
{
    //get the method with the specified name and parameter list
    Type[] argTypes = args.Select(arg => arg.GetType()).ToArray();
    MethodInfo method = this.GetType().GetMethod(methodName, argTypes);
    //check if the method exists and invoke it
    if (method != null)
        method.Invoke(this, args);
}

备注：MethodInfo.Invoke方法实际上返回一个object，因此您可以通过指定返回类型并使用return关键字以及适当的强制转换或其他将结果转换为所需类型的方法（如果可能）来定义Call方法来返回某个值 - 请记住检查它是否是。

如果不满足条件 3.，我会继续编写扩展方法。下面是一个返回泛型值的扩展方法的示例，我认为在大多数情况下应该足够了（同样，它不适用于ref或out），并且应该适用于 .NET Framework 中几乎所有可能的对象（我很感激指出一个反例）：

public static class Extensions
{
    //invoke a method with the specified name and parameter list
    // and return a result of type T
    public static T Call<T>(this object subject, string methodName, params object[] args)
    {
        //get the method with the specified name and parameter list
        Type[] argTypes = args.Select(arg => arg.GetType()).ToArray();
        MethodInfo method = subject.GetType().GetMethod(methodName, argTypes);
        //check if the method exists
        if (method == null)
            return default(T); //or throw an exception
        //invoke the method and get the result
        object result = method.Invoke(subject, args);
        //check if something was returned
        if (result == null)
            return default(T); //or throw an exception
        //check if the result is of the expected type (or derives from it)
        if (result.GetType().Equals(typeof(T)) || result.GetType().IsSubclassOf(typeof(T)))
            return (T)result;
        else
            return default(T); //or throw an exception
    }
    //invoke a void method more conveniently
    public static void Call(this object subject, string methodName, params object[] args)
    {
        //invoke Call<object> method and ignore the result
        subject.Call<object>(methodName, args);
    }
}

然后，您应该能够使用例如someObject.Call<string>("ToString")而不是someObject.ToString() 。最后，在这一点上，我强烈建议：

1. 如果可能，请使用比object更具体的类型

2. 使用一些比Call更复杂和唯一的名称 - 如果某些类定义了具有相同签名的方法，它可能会被掩盖

3. 查找协方差和逆变以获得更有用的知识