Question

比方说，我有一个方法，其中有个多条语句，当方法调用时，将执行多个语句，除了一个。（一个不会执行的语句将根据传递给该方法的参数来决定。）

如何实现上述方案？

我到目前为止所做的事情。

我有以下方法。

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语句或其他任何方式（更好）来做事？

注意：-这里的sum += //something只是语句之一，该语句不必仅是加法语句（可以是任何东西）。

Answer 1

您可以使用包含Dictionary个对象（代表的现代变体）的Action：

int GetSum(Abc abc)
{
    int sum = 0;
    var actionDict = new Dictionary<Abc, Action>
        {
            { Abc.A, () => sum += 23 },
            { Abc.B, () => sum += 68 },
            { Abc.C, () => sum += 96 },
            { Abc.D, () => sum += 57 },
            { Abc.E, () => sum += 63 }
        };

    foreach (var key in actionDict.Keys)
        if (key != abc) actionDict[key]();

    return sum;
}

请注意，对于字典， .Keys的顺序是不可预测的。

对于可预测的订单，您需要使用一组KeyValuePair，如下所示：

int GetSum(Abc abc)
{
    int sum = 0;
    var actions = new List<KeyValuePair<Abc, Action>>
    {
        KVP(Abc.A, () => sum += 23),
        KVP(Abc.B, () => sum += 68),
        KVP(Abc.C, () => sum += 96),
        KVP(Abc.D, () => sum += 57),
        KVP(Abc.E, () => sum += 63)
    };

    foreach (var action in actions)
        if (action.Key != abc) action.Value();

    return sum;
}

KeyValuePair<Abc, Action> KVP(Abc x, Action y)
{
    return new KeyValuePair<Abc, Action>(x, y);
}

Answer 2

通常，您要求的是switch语句的相反形式；这不是一回事。我还要说，您关于“ if过多”的陈述是主观的；如果这是必需的，那么您所拥有的是一种相当简单的实现方法，我必须有一个具体的理由来寻求一个“更聪明”（即“更难阅读”）的解决方案。 / p>

但是在您列出的 specific 情况下，您可以颠倒逻辑，然后使用常规的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条语句的运行。）

Answer 3

类似的答案是@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
}

@PeterB的答案确实很棒，可以轻松修改字典（新值，删除或修改其中的一个），甚至可以更改工作。
如果您只想对自己的值求和，我的只是提供了“小”快捷方式。

如何根据条件执行除一条语句以外的所有语句？

3 个答案: