Question

假设我有6种方法：Method1()，Method2()，Method3()，Method4()，Method5()和Method6()。我还有另一种方法SuperMethod(int nr)，它将调用其他方法之一。如果SuperMethod的输入为1，则会调用Method1()，依此类推。

这可以在没有switch语句或堆叠if-else语句的情况下以优雅的方式完成吗？

我应该补充一点，这不是我正在编写的重要生产代码，因此性能不是问题。

Answer 1

你可以使用代表，这对解决短程序的现实世界问题也很有意义：

    public void CollatzTest(int n)
    {
        var f = new Func<int, int>[] { i => i / 2, i => i * 3 + 1 };

        while (n != 1)
            n = f[n % 2](n);
    }

也适用于操作和直接方法引用

    private void DelegateActionStartTest()
    {
        Action[] Actions = new Action[] { UselesstTest, IntervalTest, Euler13 };

        int nFunction = 2;

        Actions[nFunction]();
    }

Answer 2

假设我有6种方法：Method1（），Method2（）......

然后你有可怕的方法名称。我会适当地命名方法（基于它们做什么和/或返回），然后使用Dictionary<int,Func<???>>创建整数到方法的映射。

SuperMethod（另一个可怕的方法名称）然后会在字典中查找该方法并执行它。

Answer 3

void Method1() { Console.WriteLine("M1"); }

void Method2() { Console.WriteLine("M2"); }

void SuperMethod(int nr)
{
    var mi = this.GetType().GetMethod("Method" + nr, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
    mi.Invoke(this, null);
}

Answer 4

我只想使用带有静态列表或数组的静态类。持续的查找时间和访问，因为整数是你的关键，它的连续字典提供的优势很小。

static class Super
{
    static void M1()
    {
    }
    static void M2()
    {
    }
    static List<Action> Actions = new List<Action>(); 
    static Super()
    {
        Actions.Add(M1);
        Actions.Add(M2); 
    }
    static void CallSupper(int nr)
    {
        try
        {
            Actions[nr - 1](); 
        }
        catch (Exception ex)
        {

        }
    }
}

Answer 5

在第一个例子中，我可能会重新设计（正如其他人所评论的那样）。

如果你真的想使用反射并假设我们在一个类实例中，你可以这样做

void SuperMethod(int nr)
{   
    MethodInfo methodInfo = type.GetMethod("Method" + nr);
    methodInfo.Invoke(this, null);
}

按编号调用方法

5 个答案: