我应该如何在 C# 中重写一个非常大的复合 if 语句？

Question

在我的 C# 代码中，我有一个 if 语句，它的开头很天真：

if((something == -1) && (somethingelse == -1) && (etc == -1)) {
    // ...
}

它正在增长。 我想现在里面一定有20个条款。

我应该如何处理这个问题？

Answer 1

虽然我喜欢达里奥的解决方案（正如我所评论的，我将它放在一个布尔函数中，这样我就不必在 if 的条件部分中有一个新的...）我不确定有什么问题：

if((something == -1) &&
   (somethingElse == -1) &&
   (elseElse == -1) &&
   ...
  )

我我认为这可能比我必须处理的许多 ((A && B) || (C &&(D||E))) 更容易阅读......

Answer 2

我这样做的方式除了我之外没有人喜欢。 我不在乎代码是否“看起来不错”。 如果我在该条件中获得了 >1 测试，则意味着我可能想要更多，或者我可能想对其中一些进行注释或注释，并且我想简化此类更改的制作。

所以我这样编码：

if (true
  && test_1
  && test_2
  ...
  )
{
  ...
}

这使得注释掉测试或添加新测试变得很容易，作为 1 行编辑。

但我会第一个承认，它并不声称很漂亮。

Answer 3

如果你真的必须检查所有这些条件，你就无法摆脱它们。 你只能重构它并使其更具可读性，但逻辑保持不变。

我很惊讶没有人提到任何有关重新设计代码的事情。 你真的需要 20 个不同的状态吗？ 根据我的经验，许多状态通常依赖于其他状态，因此在逻辑上通常是多余的。

重构代码可能会帮助您更好地理解代码以及状态如何相互耦合。 如果我是你，我会先从这里开始:)

Answer 4

像这样的事情

我会进一步解释一下。 （并修复愚蠢的错误：S）

//Interface to be able to which classes are able to give a boolean result used in the if stuff
public interface IResultable
{
    bool Result();
}

//A list that is IResultable itself it gathers the results of the IResultables inside.
public class ComparatorList<T> : List<T>, IResultable where T : IResultable
{
    public bool Result()
    {
        bool retval = true;
        foreach (T t in this)
        {
            if (!t.Result())
            {
                retval = false;
            }
        }
        return retval;
    }
}

//Or two bools
public class OrComparator : IResultable
{
    bool left;
    bool right;

    public OrComparator(bool left, bool right)
    {
        this.left = left;
        this.right = right;
    }
    #region IResultable Members

    public bool Result()
    {
        return (left || right);
    }

    #endregion
}

// And two bools
public class AndComparator : IResultable
{
    bool left;
    bool right;

    public AndComparator(bool left, bool right)
    {
        this.left = left;
        this.right = right;
    }
    #region IResultable Members

    public bool Result()
    {
        return (left && right);
    }

    #endregion
}

// compare two ints
public class IntIsComparator : IResultable
{
    int left;
    int right;

    public IntIsComparator(int left, int right)
    {
        this.left = left;
        this.right = right;
    }
    #region IResultable Members

    public bool Result()
    {
        return (left == right);
    }

    #endregion
}

您是否有很多 if 语句，这可能很酷：）

所以我们有这个结构来处理大量比较。 我将给出一个小实现示例。

//list of ands
ComparatorList<AndComparator> ands = new ComparatorList<AndComparator>();    
ands.Add(new AndComparator(true,true));

//list of ors
ComparatorList<OrComparator> ors = new ComparatorList<OrComparator>();
ors.Add(new OrComparator(false, true));

//list of intiss
ComparatorList<IntIsComparator> ints = new ComparatorList<IntIsComparator>();
ints.Add(new IntIsComparator(1, 1));

//list of all things :)
ComparatorList<IResultable> collected = new ComparatorList<IResultable>();
collected.Add(ands);
collected.Add(ors);
collected.Add(ints);

// if all things are as they must be :)
if (collected.Result())
{
    //Evertything is as it schould be :)
}

Answer 5

你说你正在查看字符串，那么有人已经评论过这样的东西怎么样？

        var items = new List<string>();

        items.Add("string1");
        items.Add("string2");

        if (items.Contains("string2"))
        {
            // do something
        }

您甚至可以从某种配置文件中获取值来填充列表。

Answer 6

尽可能使用门。

if 语句

if(bailIfIEqualZero != 0 && 
   !string.IsNullOrEmpty(shouldNeverBeEmpty) &&
   betterNotBeNull != null &&
   !betterNotBeNull.RunAwayIfTrue &&
   //yadda

重构版本

if(bailIfIEqualZero == 0)
  return;

if(string.IsNullOrEmpty(shouldNeverBeEmpty))
  return;

if(betterNotBeNull == null || betterNotBeNull.RunAwayIfTrue)
  return;

//yadda

Answer 7

将其分解为一个函数，并使每个条件成为一个保护子句：

int maybe_do_something(...) {
    if(something != -1)
        return 0;
    if(somethingelse != -1)
        return 0;
    if(etc != -1)
        return 0;
    do_something();
    return 1;
}

Answer 8

假设所有这些条件确实必要，您可以将这些条件合并到一个或多个超级布尔值或函数调用中以增强可读性。

例如，

bool TeamAIsGoForLaunch = BobSaysGo && BillSaysGo;
bool TeamBIsGoForLaunch = JillSaysGo && JackSaysGo;

if (TeamAIsGoForLaunch && TeamBIsGoForLaunch && TeamC.isGoForLaunch())

Answer 9

需要考虑的一件事是为什么你有这么多子句。 正如 SWITCH 语句通常表明您应该将选择移至子类中一样，大量复杂的 IF 语句链可能表明您在一个地方组合了太多概念（以及决策）。

作为例子，我将使用计算佣金的例子。 在我构建的一个系统中，佣金率取决于给予批发商的佣金金额，批发商将一些佣金转嫁给零售商。 批发商给零售商的金额取决于零售商和批发商之间的具体协议（基于合同）。 批发商获得的金额同样取决于产品线、具体产品和销售产品的数量。

除此之外，还有基于客户状态、特定产品定制等的额外“例外”规则。这都可以通过复杂的 IF 语句链来解决，但我们改为使用应用程序数据驱动的。

通过将所有这些信息放入表格中，我们就能够传递数据规则。 首先将触发批发商的通用规则，然后将触发任何覆盖规则。 然后，掌握了基本批发商佣金后，我们将运行批发商到零售商的通用规则，然后是这些规则的例外情况。

这将庞大的逻辑变成了一个简单的四步过程，每个步骤只需进行数据库查询即可找到要应用的正确规则。

这当然可能不适用于您的情况，但通常像这样的大型复合体实际上意味着要么没有足够的类来划分责任（我们问题的另一个解决方案可能是包含特定规则和覆盖的工厂类），或者功能应该是数据驱动的。

Answer 10

将其重构为函数。

bool Check()
{
  return (something == -1) && (somethingelse == -1) && (etc == -1);
}

或者，您可以在 Check 函数中构建更具可读性的代码/逻辑。

Answer 11

有很多方法可以解决这个问题，但让我选择一些。

首先，存在一种情况，即所有条件（if 语句中的所有 AND 条件）+ 如果它们都为真则执行的代码是一次性情况。

在这种情况下，请使用您拥有的代码。 您可能想要执行其他几个人已经建议的操作，重写以使用 Guard 子句类型的代码。

换句话说，不是这样：

if (a && b && c && d && ......)
    DoSomething();

... 你重写为类似这样的内容：

if (!a) return;
if (!b) return;
if (!c) return;
if (!d) return;
if (!...) return;
DoSomething();

为什么？ 因为一旦你开始将 OR 条件引入其中，就很难阅读代码并弄清楚将会发生什么。 在上面的代码中，您将条件拆分为每个 AND 运算符 (&&)，因此代码变得更易于阅读。 基本上，您将代码从“如果这个和那个，或者那个其他事情和那个第三件事，或者其他一些事情，然后做某事”重写为“如果这个，那么退出；如果那个其他事情；然后退出；如果某个其他事情；然后退出；如果以上都不是，则做某事”。

然而，在很多情况下，你也会遇到可重用性的情况。 如果其中一些标准出现在其他地方，但实际执行的代码 (DoSomething) 不同，那么我会再次采用其他人已经建议的内容。 将条件重写为根据评估条件的结果返回布尔值结果的方法。

例如，什么更容易阅读，这个？

if (a && b && c && d && e && f && (h || i) && (j || k) || l)

或者这样：

if (CanAccessStream() && CanWriteToStream())

假设所有这些字母都可以分为这两个标准。

在这种情况下，我会采用一些标准并将其放入这些方法中，并为标准选择适当的名称。

第三个选项是代码中多个地方的标准不同，但实际执行的代码是相同的。

在这种情况下，我会重写，以便将条件分组在一起并对方法进行分层，以便调用一个方法将检查某些条件，然后调用另一个方法，该方法将检查其他一些条件等。

例如，您可以这样写：

if (stream != null && buffer != null && inBuffer > 0 && stream.CanWrite)
  stream.Write(buffer, 0, inBuffer);
else
    throw new InvalidOperationException();

或你可以这样写：

if (inBuffer > 0)
{
    Debug.Assert(buffer != null);
    WriteToStream(buffer, inBuffer);
}

...

private void WriteToStream(Byte[] buffer, Int32 count)
{
    if (stream.CanWrite)
        stream.Write(buffer, 0, count);
    else
        throw new InvalidOperationException();
}

我想说第二种方法比第一种方法更容易阅读，并且更可重用。

Answer 12

对您的值列表执行聚合操作。

if (new[] { something, somethingelse, ... }.All(x => x == -1)) {
}

*编辑：给数据添加额外的行：

var Data = new[] { something, somethingelse, ... };
if (Data.All(x => x == -1)) {
}

Answer 13

看起来您有 3 条信息，它们一起代表应用程序中的特定状态。 与其打开这三个状态，为什么不创建一个封装它们的值呢？ 然后，您可以在创建时使用对象层次结构或委托来绑定您尝试运行的操作。

Answer 14

您可以将其重构为函数，并返回表示正确情况的枚举值：

if(something != -1)
    return MyEnum.Something;
if(somethingelse != -1)
    return MyEnum.SomethingElse;
if(etc != -1)
    return MyEnum.SomethingElseEntirely;
return MyEnum.None;

Answer 15

您还可以将状态纳入一个类中。

class mystate
{
    int something;
    int somethingelse;
    int etc;

    bool abletodostuff()
    {
        return (something == -1) && (somethingelse == -1) && (etc == -1);
    }
}

Answer 16

我不知道 C#，但它似乎包含 条件运算符。 如果你的条件很短，你可以用漂亮的表状结构替换长的 if/elsif/else 链，如下所示：

return   something == 0      ? 0
       : somethingelse == -1 ? 1
       : yetanotherthing > 2 ? 2
       :                       3; # default

Answer 17

您可以探索的另一个途径是使用复合表达式。 这些表达式（这是 LINQ 在 .NET 框架中工作的基础）允许您基于所有这些条件创建表达式树，然后业务逻辑代码可以简单地对顶级表达式进行操作以获取 true/false 结果。

要评估表达式，您可以使用 访问者模式

这使您可以轻松构建树的条件。 这些树甚至可以序列化，让您保留做出决定的条件。 这里有很多机会。

Answer 18

在一个“if”中看到多个子句的情况并不常见。 当您需要执行某些行而不考虑某些条件的真实性时，您通常会发现需要嵌套“if”才能获得所需的逻辑。 如果不需要的话，如果它们都需要同时进行测试，我并不是说将它们嵌套起来。 仅当有一些通用功能时。
另一个考虑因素是使用某些条件集的结果设置一个布尔变量，这可能会更容易理解。
如果您的变量是数组或集合，您可以循环遍历它们吗？ 您是否将它们全部针对 -1 进行测试？