在代码中高效表达 2x2 逻辑网格

Question

在事件处理程序中，我响应值的更改。我可以访问旧值和新值，并希望根据变化进行某些操作。

每个不同的结果都会执行一些操作/功能 X、Y 或 Z 的组合。Z 接受 -1 和 1 之间的参数。执行这些操作的顺序并不重要。

看下面的逻辑网格。旧值是标签的最左边一列，新值是标签的顶行：

          New:
          0          !=0
          --------   -------
Old:  0 | nothing    Y, Z(1)
    !=0 | X, Z(-1)   X, Y    -- Z(0) is okay but not required for this quadrant

表示这一点的好方法是什么？

我正在使用 C# 工作，但会接受任何语言的答案，因为这并不是真正的语言问题 — 我可以翻译任何语言。

示例：

if (oldvalue == 0 && newvalue == 0) return;
if (oldvalue != 0) X();
if (newvalue != 0) Y();
Z(oldvalue != 0 ? -1 : 0 + newvalue != 0 ? 1 : 0);

我认为这看起来不错，但还有其他方法可以完成。

int which = (oldvalue == 0 ? 0 : 1) + (newvalue == 0 ? 0 : 2)

switch (which) {
   case 1:
      X(); Z(-1);
      break;
   case 2:
      Y(); Z(1);
      break;
   case 3:
      X(); Y();
      break;
}

这实际上比我正在处理的情况稍微简单一些。如果旧值和新值非零且彼此相等，则将新值视为 0。

请随意按给定的方式或使用此附加约束来回答。还有一点，但我认为一开始就太多了。如果之后事情看起来很有趣，我将在此处或在新问题中介绍其余内容。

我想我问这个问题是因为我经常遇到这些逻辑网格的东西，而且它们并不总是 2x2，有时它们会更大一些。很高兴注意到我可以用整个“条纹”处理一些响应，例如注意到每次 oldvalue != 0 时都会完成 X，但似乎我开始遇到一种模式，需要一些表达逻辑来处理它更普遍，而不是费力地把它变成 if then else 语句。我的意思是，如果我能够提供一种逻辑网格并让编译器找出处理它的最佳方法，那就太酷了。

只是进行一些疯狂的头脑风暴：

Conditions:
oldvalue == 0 ? 0 : 1
newvalue == 0 ? 0 : 2

Actions:
X = {false, true, false, true}
Y = {false, false, true, true}
Z(-1) = true where condition = 1
Z(1) = true where condition = 2

你有什么想法？我会奖励任何物质上的参与。

Answer 1

让我们从另一个角度来看您的问题。在设计代码体时，我尝试应用以下原则：

1. 使其正确。
2. 说清楚。
3. 使其简洁。
4. 让它快点。
   ...按这个顺序。

所有这些，在某种程度上，都是主观的。然而，理性的人往往会找到共同点，而且对于他们的对立面往往也能达成更多共识。但除此之外...

这里的首要任务是确保您的代码能够正常工作。显然，有多种实现可以实现这一目标 - 但我还要补充一点重要的是它很容易证明实现是正确的。实现此目的的一种方法是使代码读起来更像规范（稍后会详细介绍）。

第二个优先事项是确保将来当开发人员（包括原作者！）查看此代码时，他们将能够立即理解它在做什么。实现越复杂（读作：花哨），开发人员就越难立即理解代码的作用。

第三个优先事项 - 简短、简洁的代码，与前两个优先事项部分相反。希望使代码更简洁，可能会导致您使用比实际需要更复杂的结构。解决问题。虽然保持代码简短很重要，但我们不应该通过使其变得难以理解的密集来做到这一点。

最后一个优先事项 - 性能 - 仅在重要时才重要。 我的意思是，从性能的角度来看，您不应该使实现复杂化，除非您已执行分析并将其识别为瓶颈在你的系统中。

既然我们已经了解了推动我们决策的原则，那么让我们将它们应用于当前的问题。您已经提供了关于代码应该如何运行的非常清晰的规范。让我们尝试遵守它们：

void YourMethod( int oldValue, int newValue )
{
    bool oldValueNonZero = oldValue != 0;
    bool newValueNonZero = newValue != 0;

    if( oldValueNonZero ) { X(); }
    if( newValueNonZero ) { Y(); }
    if( oldValueNonZero && newValueNonZero ) { Z(); }
}

那么为什么我喜欢这个特定的实现。让我们分解一下。

首先，请注意，我选择创建临时布尔值来捕获测试旧值/新值是否非零的结果。通过捕获这些值，我可以避免多次执行计算，并且还可以使代码更具可读性（见下文）。

第二，通过选择描述性名称 oldValueNonZero 和 newValueNonZero，我使实现清楚地表明了我的期望。这既提高了代码的可读性，又清楚地向未来必须阅读代码的开发人员传达了我的意图。

第三，请注意 if() 测试的主体包含在 { 和 } 括号中 - 这有助于减少未来对实现的更改破坏行为的可能性 - 例如，意外地包含一个新案例。使用单行 ifs 是解决未来问题的良方。

最后，我不会尝试缩短比较并提前退出函数。如果性能极其重要，那么提前退出可能会很有用。但除此之外，如果只有一个退出点⁽¹⁾，则更容易理解方法的行为。

这段代码是否按照规范所述进行操作？我相信是的。

它容易阅读和理解吗？至少在我看来，我会说是的。

这段代码是短路逻辑的最紧凑或最复杂的方式吗？几乎肯定不是……但在我看来，它的其他品质远远弥补了这一点。

在某种程度上，您是否喜欢这种特定的代码结构取决于品味和风格。但我希望我所阐述的关于如何组织它的原则可以帮助您将来做出此类决定。

您指出，您有时会遇到类似的“逻辑网格”问题，但案例数量更多。由于两个不同的原因，此类问题可能会变得复杂：

1. 参数可以采用的值的数量不断增加 - 它们可以采用一般形式 MxN。
2. 维数增加 - 换句话说，规则中包含更多变量：MxNxOxP...xZ。

该问题的一个通用解决方案（如另一个响应所示）是将解决方案编码为多维矩阵 - 并为每种情况定义一组操作。然而，规则完全有可能重叠 - 并且为了简单起见，可能需要将等效案例折叠在一起。

我对处理一般情况的回应是……这取决于情况。如果条件可以减少到极少数情况，那么命令式 if/else 逻辑可能仍然是解决问题的最佳方法。如果条件的数量非常大，那么使用声明性方法可能是有意义的，在这种方法中，您使用某种查找表或矩阵来对情况进行编码。

^1> - 方法仅具有单个退出点这一原则的一个常见例外是先决条件。首先检查所有/任何先决条件，如果违反则使方法失败（退出），这样可以更干净地避免嵌套和反转逻辑。

Answer 2

实际上，您可以使用多维数组来缩短测试和分支过程。如果查找的结果不是固定值，而是需要完成的某种工作，则可以将该数组设为委托数组，并用方法或可执行代码 (lambda) 填充它。

像这样：

private void Y() { }
private void X() {}
private void Z(int n) {}

private void example(int oldvalue, int newvalue)
{
    var array = new Action[2, 2];
    array[0, 0] = () => { };
    array[0, 1] = () => { Y(); Z(1); };
    array[1, 0] = () => { X(); Z(-1); };
    array[1, 1] = () => { X(); Y(); };

    // invoke
    array[oldvalue == 0 ? 0 : 1, newvalue == 0 ? 0 : 1]();
}

您还可以使用内联初始化程序初始化状态数组，但我发现在显式语句中分解单元格分配更容易阅读和跟踪内容。

数组的初始化可以提前完成，也许在包含此示例函数的类的构造函数中完成。然后，示例函数中的执行将减少为

1. 评估 oldvalue == 0
2. 评估 newvalue == 0
3. 数组中的索引以检索委托
4. 执行委托以执行操作

此技术会导致非常非常小的执行开销（快速），可扩展可以很好地适应任意数量的维度，并保留代码和逻辑表之间的相关性，与到处都是混乱的 if 语句相比，这应该使它更容易理解和修改。

Answer 3

额外积分解决方案

这是一个非常有趣的主题，贡献者提供了一些深刻的见解。我认为你的问题已经得到解答，所以我将重点关注额外的学分。最简单的事情是更新您的表并将其应用到您最喜欢的解决方案。

让我们以完整描述每列条件的方式来表述问题。如果新值等于零​​或旧值，我们将从第一列开始执行操作。如果新值非零且不等于旧值，我们将从第二列执行操作。

          New == 0 || New == Old    New != 0 && New != Old
          ----------------------   ------------------------
Old == 0 | nothing                  Y, Z(1)
Old != 0 | X, Z(-1)                 X, Y    -- Z(0) is okay but not required for this quadrant

因此，在 dthorpe 的解决方案中，我们将 newValue == 0 替换为 newValue == 0 || newValue == oldValue ：

private void example(int oldvalue, int newvalue)
{
    var array = new Action[2, 2];
    array[0, 0] = () => { };
    array[0, 1] = () => { Y(); Z(1); };
    array[1, 0] = () => { X(); Z(-1); };
    array[1, 1] = () => { X(); Y(); };

    array[oldvalue == 0 ? 0 : 1, newValue == 0 || newValue == oldValue ? 0 : 1]();
}

在 LBushkin 的解决方案中，我们将 newValue != 0 替换为 newValue != 0 && newValue != oldValue 并更新相应的变量名称以保持可读性。我还要对代码位进行混蛋：

void YourMethod( int oldValue, int newValue )
{
    bool oldValueNonZero = oldValue != 0;
    bool newValueDifferentAndNonZero = newValue != 0 && newValue != oldValue;
    int zCondition = 0;

    if( oldValueNonZero ) { X(); zCondition--;}
    if( newValueDifferentAndNonZero ) { Y(); zCondition++;}
    if( zCondition != 0 ) { Z(zCondition); }
}

Tada！