C# 如何执行除基于某些条件的语句外的所有语句？

假设我有一个方法，其中有多个语句，当方法调用一个以外的语句时将执行这些语句。（将根据传递给方法的参数确定一条不执行的语句）

如何实现上述场景

到目前为止我所做的事情

我有以下方法

enum Abc
{
    A = 0,
    B = 1,
    C = 2,
    D = 3,
    E = 4,
}
int GetSum(Abc abc)
{
    int sum = 0;
    if(abc != Abc.A)
    {
        sum += 23;
    }
    if(abc != Abc.B)
    {
        sum += 68;
    }
    if(abc != Abc.C)
    {
        sum += 96;
    }
    if(abc != Abc.D)
    {
        sum += 57;
    }
    if(abc != Abc.E)
    {
        sum += 63;
    }
    return sum;
}

在向

sum

添加值之前，我正在检查是否必须根据

abc

的值进行添加

基本上，我希望如果

abc

的值是

abc.A

，那么执行除

sum+=23之外的所有语句

在我的代码中，if条件太多了。有没有办法用更少的if语句或其他方式（更好）来做事情

注意：-这里的
sum+=//something
只是其中的一个语句，不需要该语句仅为加法（它将是任何形式）。
通常，您要求的是
switch
语句的某种相反形式；这不是一件事。我还要说，你所说的“如果

s，那么s太多”是主观的；如果这是一个要求，那么你所拥有的是一个相当简单的实现它的方法，我必须有一个具体的理由，希望有一个“更聪明”（即“更难阅读”）的解决方案

但是在您列出的特定情况下，您可以颠倒逻辑，然后使用常规的

switch

语句

int GetSum(Abc abc)
{    
    int sum = 307; //23 + 68 + 96 + 57 + 63
    switch (abc) {
        case Abc.A:
            sum -= 23;
            break;
        case Abc.B:
            sum -= 68;
            break;
        // etc.
    }
    return sum;
}

---

显然，如果单个语句更复杂，以至于您无法“从末尾开始”并反转逻辑——特别是如果每个语句都有副作用——那么这种方法将不适用。但是，在更复杂的情况下，可能还有其他更合理的模式。（很可能只包括运行

if

语句。）

一般来说，您要求的是

开关的某种相反的语句；这不是一件事。我还要说，你所说的“如果

s，那么s太多”是主观的；如果这是一个要求，那么你所拥有的是一个相当简单的实现它的方法，我必须有一个具体的理由，希望有一个“更聪明”（即“更难阅读”）的解决方案

但是在您列出的特定情况下，您可以颠倒逻辑，然后使用常规的

switch

语句

int GetSum(Abc abc)
{    
    int sum = 307; //23 + 68 + 96 + 57 + 63
    switch (abc) {
        case Abc.A:
            sum -= 23;
            break;
        case Abc.B:
            sum -= 68;
            break;
        // etc.
    }
    return sum;
}

---

显然，如果单个语句更复杂，以至于您无法“从末尾开始”并反转逻辑——特别是如果每个语句都有副作用——那么这种方法将不适用。但是，在更复杂的情况下，可能还有其他更合理的模式。（很可能只包括运行

if

语句。）

您可以使用包含

操作

对象（代理的现代变体）的

字典

：

---

您可以使用包含

操作

对象的

字典

（代理的现代变体）：

---

与@PeterB的答案类似，但仅适用于您的sum示例：

int Method(Abc abc)
{
    Dictionary<Abc, int> dictionary = new Dictionary<Abc, int>()
    {
        { Abc.A, 23 },
        { Abc.B, 68 },
        { Abc.C, 96 },
        { Abc.D, 57 },
        { Abc.E, 63 }
    };

    return dictionary
        .Where(kvp => kvp.Key != abc)  // filter where Abc is different
        .Sum(kvp => kvp.Value);        // sum all values after filtering
}

int方法（Abc）
{
字典=新字典（）
{
{Abc.A，23}，
{Abc.B，68}，
{Abc.C，96}，
{Abc.D，57}，
{Abc.E，63}
};
返回字典
.Where（kvp=>kvp.Key！=abc）//过滤abc不同的地方
.Sum（kvp=>kvp.Value）；//对筛选后的所有值求和
}

@PeterB的答案非常好，可以在字典中轻松修改（新值、删除或修改），甚至可以更改要执行的工作。

---

如果你只想对你的值求和，我的只是提供了一个“小”的快捷方式。

与@PeterB的答案类似，但仅适用于你的求和示例：

int Method(Abc abc)
{
    Dictionary<Abc, int> dictionary = new Dictionary<Abc, int>()
    {
        { Abc.A, 23 },
        { Abc.B, 68 },
        { Abc.C, 96 },
        { Abc.D, 57 },
        { Abc.E, 63 }
    };

    return dictionary
        .Where(kvp => kvp.Key != abc)  // filter where Abc is different
        .Sum(kvp => kvp.Value);        // sum all values after filtering
}

int方法（Abc）
{
字典=新字典（）
{
{Abc.A，23}，
{Abc.B，68}，
{Abc.C，96}，
{Abc.D，57}，
{Abc.E，63}
};
返回字典
.Where（kvp=>kvp.Key！=abc）//过滤abc不同的地方
.Sum（kvp=>kvp.Value）；//对筛选后的所有值求和
}

@PeterB的答案非常好，可以在字典中轻松修改（新值、删除或修改），甚至可以更改要执行的工作。

---

如果你只想对你的值求和，我的方法只会给你一个“小”的快捷方式。

这感觉像是一个XY问题-。您的代码试图实现什么？而且这似乎非常适合。除此之外，您还可以使用-关键字。您的示例是否与实际代码相去甚远？或者它真的是一些相对简单的计算，没有进一步的副作用吗？这感觉像是一个XY问题-。您的代码试图实现什么？而且这似乎非常适合。除此之外，您还可以使用-关键字。您的示例是否与实际代码相去甚远？或者它真的是一些相对简单的计算，没有进一步的副作用吗？多么巧合——计算器上总共307个！因为这些值似乎不是标志，所以我甚至只需预计算一个数组，并使用枚举值作为索引。@Fildor-可能。视情况而定。如果其中一个值发生更改，则更新代码将变得更加困难。（对于一个预先计算的数组，你必须改变5到6件事。对于我上面展示的反向逻辑开关，有2件事。对于最初的实现，OP不想要，只有1件事真正改变了。）这就是我的意思，我需要一个聪明的理由，这就是为什么这个问题可能会受到过度简化的影响（甚至排除了更复杂的设计解决方案）绝对同意。真是巧合-计算器上总共307个！因为这些值似乎不是标志，我甚至只需预计算一个数组，并使用枚举值作为索引。@Fildor-可能。视情况而定。如果其中一个值发生更改，则更新代码会更困难。（使用