在我的 C# 代码中，我有一个很天真地开始的 if 语句：
if((something == -1) && (somethingelse == -1) && (etc == -1)) {
// ...
}
它正在增长。我想现在肯定有20个子句。
我应该如何处理这个？
【问题讨论】：
标签： c# refactoring structure if-statement guard-clause
尽可能使用大门。
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
【讨论】：
将其分解为一个函数，并使每个条件成为一个保护子句：
int maybe_do_something(...) {
if(something != -1)
return 0;
if(somethingelse != -1)
return 0;
if(etc != -1)
return 0;
do_something();
return 1;
}
【讨论】：
假设所有这些条件确实是必要的，您可以将这些条件合并到一个或多个超级布尔值或函数调用中以增强可读性。
例如，
bool TeamAIsGoForLaunch = BobSaysGo && BillSaysGo;
bool TeamBIsGoForLaunch = JillSaysGo && JackSaysGo;
if (TeamAIsGoForLaunch && TeamBIsGoForLaunch && TeamC.isGoForLaunch())
【讨论】：
要考虑的一件事是为什么你有这么多子句。正如 SWITCH 语句通常表明您应该将选择转移到子类中一样，大型复杂的 IF 语句链可能表明您在一个地方组合了太多概念（以及决策）。
作为一个例子，我将使用计算佣金的例子。在我建立的一个系统中，佣金率取决于给予批发商的佣金金额，批发商将一些佣金转给零售商。批发商给零售商的金额取决于零售商和批发商之间的具体协议（基于合同）。批发商获得的金额同样取决于产品线、特定产品和销售产品的数量。
除此之外，还有基于客户状态、特定产品定制等的额外“例外”规则。这可以全部在复杂的 IF 语句链中制定，但我们改为制定应用程序数据驱动。
通过将所有这些信息放入表格中，我们就能够传递数据规则。首先会触发批发商的通用规则，然后会触发任何覆盖规则。然后，有了基础批发商佣金，我们将运行批发商到零售商的通用规则，然后是这些规则的例外。
这将一个庞大的逻辑毛球变成了一个简单的四步流程，每一步都简单地进行数据库查询以找到要应用的正确规则。
这当然可能不适用于您的情况，但通常这样的大型复合体实际上意味着没有足够的类来划分责任（我们问题的另一种解决方案可能是包含特定规则的工厂类和覆盖），或者功能应该是数据驱动的。
【讨论】：
将其重构为一个函数。
bool Check()
{
return (something == -1) && (somethingelse == -1) && (etc == -1);
}
或者，您可以在 Check 函数中构建更具可读性的代码/逻辑。
【讨论】：
有很多方法可以解决这个问题，但让我挑几个。
首先，所有条件（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）不一样，那么我会再次选择其他人已经建议的内容。根据评估条件的结果，将条件重写为返回 Boolean 结果的方法。
例如，什么更容易阅读，这个？
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();
}
我会说第二种方式比第一种方式更容易阅读，并且更可重复使用。
【讨论】：
对您的值列表执行聚合操作。
if (new[] { something, somethingelse, ... }.All(x => x == -1)) {
}
*编辑：给数据一个额外的行：
var Data = new[] { something, somethingelse, ... };
if (Data.All(x => x == -1)) {
}
【讨论】：
看起来您有 3 条信息共同代表应用程序中的特定状态。与其打开这 3 个状态，不如创建一个封装它们的值？然后，您可以在创建时使用对象层次结构或委托来绑定您尝试运行的操作。
【讨论】：
您可以将它重构为一个函数，并返回一个 Enum 值，该值代表正确的情况：
if(something != -1)
return MyEnum.Something;
if(somethingelse != -1)
return MyEnum.SomethingElse;
if(etc != -1)
return MyEnum.SomethingElseEntirely;
return MyEnum.None;
【讨论】：
您也可以将状态分解到一个类中。
class mystate
{
int something;
int somethingelse;
int etc;
bool abletodostuff()
{
return (something == -1) && (somethingelse == -1) && (etc == -1);
}
}
【讨论】：
我不懂 C#，但它似乎包括 conditional operator。如果你的条件很短，你可以用漂亮的表格结构替换长的 if/elsif/else 链，如下所示：
return something == 0 ? 0
: somethingelse == -1 ? 1
: yetanotherthing > 2 ? 2
: 3; # default
【讨论】：
您可能会探索的另一个途径是使用复合表达式。这些表达式（这是 LINQ 在 .NET 框架中工作的基础）允许您根据所有这些条件创建表达式树，然后业务逻辑代码可以简单地对顶级表达式进行操作以获取真/假结果.
要评估表达式，您可以使用visitor pattern
这使您可以轻松地组合条件树。这些树甚至可以序列化，让您坚持做出决定的条件。这里有很多机会。
【讨论】：
在一个“if”中看到这么多子句并不常见。当您需要执行某些行而不管某些条件的真实性时，您通常会发现您需要嵌套“ifs”以获得所需的逻辑。我不是说如果你不需要嵌套它们，如果它们都需要同时进行测试。只有当有一些共同的功能。 另一个考虑是设置一个布尔变量，其中包含一些这些条件的结果，这可能更容易理解。 如果你的变量是一个数组或集合，你能遍历它们吗？您是否针对 -1 对它们进行了测试？
【讨论】：
虽然我喜欢达里奥的解决方案（正如我评论的那样，我将它放在一个布尔函数中，所以我不必在 if 的条件部分添加一个新的...）我不确定出了什么问题与：
if((something == -1) &&
(somethingElse == -1) &&
(elseElse == -1) &&
...
)
我认为这可能比我必须处理的许多 ((A && B) || (C &&(D||E))) 更容易阅读......
【讨论】：
我这样做的方式除了我之外没人喜欢。我不在乎代码是否“看起来不错”。如果我在那个条件下获得了 >1 个测试，这意味着我可能想要更多，或者我可能想要评论其中一些或评论，并且我想简化这些更改的制作。
所以我这样编码：
if (true
&& test_1
&& test_2
...
)
{
...
}
这使得注释测试或添加新测试变得容易，如 1 行编辑。
但我会第一个承认，它并不声称漂亮。
【讨论】：
如果你真的必须检查所有这些条件，你就无法摆脱它们。您只能重构它并使其更具可读性，但逻辑保持不变。
我很惊讶没有人提到任何关于重新设计代码的事情。你真的需要 20 种不同的状态吗？根据我的经验，很多状态通常依赖于其他状态，因此通常在逻辑上是多余的。
重构代码可能有助于您更好地理解代码以及状态如何相互耦合。如果我是你，我会先从这里开始:)
【讨论】：
还有这样的事情
我会进一步解释一下。 （并修复愚蠢的错误：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 :)
}
【讨论】：
您说您正在查看字符串，那么有人已经评论过这样的事情怎么样。
var items = new List<string>();
items.Add("string1");
items.Add("string2");
if (items.Contains("string2"))
{
// do something
}
您甚至可以从某种配置文件中获取值来填充列表。
【讨论】：