C# 我可以避免使用非常大的'；开关'；块以访问400块程序代码？

我用C#编写了一个应用程序，目前它包括近400个数学函数，每个函数都有自己的整数ID。为了访问函数代码，我的应用程序目前将函数ID提供给一个巨大的“开关”块，每个函数有一个“案例”块：总共近400个“案例”块。这似乎可以无缝且非常快速地工作，但有没有更有效的方法将代码块与函数标识符匹配？

更好的解决方案是将每个函数封装在其自己的类中，然后在所需的函数中使用toswap

将每个函数放在自己的类中有一个优点，即在一个位置查看函数的代码更简单，并且保持良好状态，每个类只负责实现该函数的代码。这也将使测试这些功能变得更容易

这也意味着将来添加函数会更加灵活，因为您将有机会从外部源添加函数，而无需重新编译

---

这种方法的另一个好处是，由于函数都将实现一个接口，因此可以在加载时扫描程序集以查找这些实现，从而自动将新函数添加到可用函数列表中，而无需任何额外的工作

更好的解决方案是将每个函数封装在其自己的类中，然后使用来交换所需的函数

将每个函数放在自己的类中有一个优点，即在一个位置查看函数的代码更简单，并且保持良好状态，每个类只负责实现该函数的代码。这也将使测试这些功能变得更容易

这也意味着将来添加函数会更加灵活，因为您将有机会从外部源添加函数，而无需重新编译

---

这种方法的另一个好处是，由于函数都将实现一个接口，因此可以在加载时扫描程序集以查找这些实现，从而自动将新函数添加到可用函数列表中，而无需任何额外的工作

听起来好像你想要一本

字典

或类似的东西

// Better, use an *enum* of function IDs...
private static readonly Dictionary<int, Func<double, double>> Functions =
    new Dictionary<int, Func<double, double>>
{
    { 0, Math.Sqrt },
    { 100, x => x * 2 },
    ...
};

//最好使用*enum*函数ID。。。
专用静态只读字典函数=
新词典
{
{0，Math.Sqrt}，
{100，x=>x*2}，
...
};

请注意，正如它引用Math.Sqrt一样，它也可以引用您自己的方法—您不必将所有逻辑都放在集合初始值设定项中。我可能会将任何函数分解成一个方法，而不仅仅是一个表达式

然后，您可以这样应用它：

public void Apply(int functionId, double value)
{
    Func<double, double> function;
    if (!Functions.TryGetValue(functionId, out function))
    {
        // Throw an exception or whatever
    }
    return function(value);
}

function add(a,b) {
    return a + b;
}

function subtract(a,b) {
    return a - b;
}

public-void-Apply（int-functionId，双值）
{
Func函数；
if（！Functions.TryGetValue（functionId，out函数））
{
//抛出异常或其他异常
}
返回函数（值）；
}

请注意，我在这里使用的词典是通用的；如果函数ID为0…n，则可以改用数组

---

如开头的注释所述，使用函数ID的枚举比只使用整数更整洁。

听起来像是想要一个

字典或类似的东西

// Better, use an *enum* of function IDs...
private static readonly Dictionary<int, Func<double, double>> Functions =
    new Dictionary<int, Func<double, double>>
{
    { 0, Math.Sqrt },
    { 100, x => x * 2 },
    ...
};

//最好使用*enum*函数ID。。。
专用静态只读字典函数=
新词典
{
{0，Math.Sqrt}，
{100，x=>x*2}，
...
};

请注意，正如它引用Math.Sqrt一样，它也可以引用您自己的方法—您不必将所有逻辑都放在集合初始值设定项中。我可能会将任何函数分解成一个方法，而不仅仅是一个表达式

然后，您可以这样应用它：

public void Apply(int functionId, double value)
{
    Func<double, double> function;
    if (!Functions.TryGetValue(functionId, out function))
    {
        // Throw an exception or whatever
    }
    return function(value);
}

function add(a,b) {
    return a + b;
}

function subtract(a,b) {
    return a - b;
}

public-void-Apply（int-functionId，双值）
{
Func函数；
if（！Functions.TryGetValue（functionId，out函数））
{
//抛出异常或其他异常
}
返回函数（值）；
}

请注意，我在这里使用的词典是通用的；如果函数ID为0…n，则可以改用数组

如开头的注释所述，使用函数ID的枚举比仅使用整数更为整洁。
进一步考虑到使用
字典
的可能性，注意到有六个或更多字符串大小写和一个默认大小写会导致编译器生成一个
字典
。那么，为什么不在编译过程中跳过转换呢？
关于使用
字典的可能性，进一步观察到有六个或更多的字符串大小写和一个默认大小写会导致编译器生成一个
字典。那么，为什么不在编译过程中跳过该转换呢？
据我所知，编译器已经优化了包含多个项目的
语句，以便在内部使用查找表，因此切换到例如
字典
时的性能增益应该最小。正如往常一样，您应该衡量这两种方法来做出决定。
据我所知，编译器已经优化了包含多个项的switch
语句，以便在内部使用查找表，因此通过切换到例如
字典
所获得的性能增益应该是最小的。与往常一样，您应该衡量这两种方法来做出决策。
听起来您是这样编写代码的（psudocode）：

当你想这样写的时候：

public void Apply(int functionId, double value)
{
    Func<double, double> function;
    if (!Functions.TryGetValue(functionId, out function))
    {
        // Throw an exception or whatever
    }
    return function(value);
}

function add(a,b) {
    return a + b;
}

function subtract(a,b) {
    return a - b;
}

还是我误解了您的要求？
听起来您是这样编写代码的（psudocode）：

当你想这样写的时候：

public void Apply(int functionId, double value)
{
    Func<double, double> function;
    if (!Functions.TryGetValue(functionId, out function))
    {
        // Throw an exception or whatever
    }
    return function(value);
}

function add(a,b) {
    return a + b;
}

function subtract(a,b) {
    return a - b;
}

还是我误解了您的要求？
非线性查找词典如何？这听起来像是一场噩梦！我对通过id引用函数的其他部分很好奇。为什么