大布尔表达式比分解成谓词方法的同一个表达式更具可读性吗？[关闭]

什么更容易理解，一个大的布尔语句（相当复杂），或同一语句分解为谓词方法（很多额外的代码需要阅读）？

选项1，大布尔表达式：

    private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
    {

        return propVal.PropertyId == context.Definition.Id
            && !repo.ParentId.HasValue || repo.ParentId == propVal.ParentId
            && ((propVal.SecondaryFilter.HasValue && context.SecondaryFilter.HasValue && propVal.SecondaryFilter.Value == context.SecondaryFilter) || (!context.SecondaryFilter.HasValue && !propVal.SecondaryFilter.HasValue));
    }

选项2，条件分为谓词方法：

    private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
    {
        return MatchesDefinitionId(context, propVal)
            && MatchesParentId(propVal)
            && (MatchedSecondaryFilter(context, propVal) || HasNoSecondaryFilter(context, propVal));
    }

    private static bool HasNoSecondaryFilter(CurrentSearchContext context, TValToMatch propVal)
    {
        return (!context.No.HasValue && !propVal.SecondaryFilter.HasValue);
    }

    private static bool MatchedSecondaryFilter(CurrentSearchContext context, TValToMatch propVal)
    {
        return (propVal.SecondaryFilter.HasValue && context.No.HasValue && propVal.SecondaryFilter.Value == context.No);
    }

    private bool MatchesParentId(TValToMatch propVal)
    {
        return (!repo.ParentId.HasValue || repo.ParentId == propVal.ParentId);
    }

    private static bool MatchesDefinitionId(CurrentSearchContext context, TValToMatch propVal)
    {
        return propVal.PropertyId == context.Definition.Id;
    }

我更喜欢第二种方法，因为我将方法名称视为注释，但是我知道这是有问题的，因为您必须阅读所有方法以了解代码的作用，因此它抽象了代码的意图。

什么更容易理解

后一种方法。它不仅易于理解，而且易于编写，测试，重构和扩展。每个要求的条件都可以通过自己的方式安全地解耦和处理。

这是有问题的，因为您必须阅读所有方法来理解代码

方法的名称正确没有问题。实际上，由于方法名称将描述条件的意图，因此更容易理解。
对于围观者而言，if MatchesDefinitionId()比if (propVal.PropertyId == context.Definition.Id)

[个人而言，第一种方法使我的眼睛发痛。

如果这是使用这些谓词函数的唯一位置，则也可以改用局部bool变量：

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    bool matchesDefinitionId = (propVal.PropertyId == context.Definition.Id);
    bool matchesParentId = (!repo.ParentId.HasValue || repo.ParentId == propVal.ParentId);
    bool matchesSecondaryFilter = (propVal.SecondaryFilter.HasValue && context.No.HasValue && propVal.SecondaryFilter.Value == context.No);
    bool hasNoSecondaryFilter = (!context.No.HasValue && !propVal.SecondaryFilter.HasValue);

    return matchesDefinitionId
        && matchesParentId
        && matchesSecondaryFilter || hasNoSecondaryFilter;
}

这些也可以进一步细分并重新排序以使其更具可读性，例如

bool hasSecondaryFilter = propVal.SecondaryFilter.HasValue;

然后替换的所有实例propVal.SecondaryFilter.HasValue。然后立即出现的一件事是，hasNoSecondaryFilter在否定的HasValue属性上使用逻辑AND ，而matchesSecondaryFilter在未否定的属性上使用逻辑AND- HasValue因此并非完全相反。

通常，后者是优选的。

它使呼叫站点更加可重用。它支持DRY（意味着您可以在更改标准时更改的位置更少，并且可以更可靠地进行更改）。通常，这些子条件是可以在其他地方独立重用的东西，使您能够做到这一点。

哦，这使这些东西更容易进行单元测试，使您确信自己已正确完成。

如果介于这两个选择之间，则后者更好。这些不是唯一的选择！如何将单个功能分解为多个ifs？测试退出函数的方式以避免额外的测试，在单线测试中大致模拟“短路”。

这更容易阅读（您可能需要仔细检查示例的逻辑，但这一概念成立）：

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    if( propVal.PropertyId != context.Definition.Id ) return false;

    if( repo.ParentId.HasValue || repo.ParentId != propVal.ParentId ) return false;

    if( propVal.SecondaryFilter.HasValue && 
        context.SecondaryFilter.HasValue && 
        propVal.SecondaryFilter.Value == context.SecondaryFilter ) return true;

    if( !context.SecondaryFilter.HasValue && 
        !propVal.SecondaryFilter.HasValue) return true;

    return false;   
}

我更喜欢选项2，但建议进行一次结构性更改。将条件最后一行的两个检查合并到一个调用中。

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    return MatchesDefinitionId(context, propVal)
        && MatchesParentId(propVal)
        && MatchesSecondaryFilterIfPresent(context, propVal);
}

private static bool MatchesSecondaryFilterIfPresent(CurrentSearchContext context, 
                                                    TValToMatch propVal)
{
    return MatchedSecondaryFilter(context, propVal) 
               || HasNoSecondaryFilter(context, propVal);
}

我建议这样做的原因是，这两个检查是单个功能单元，并且在条件中嵌套括号很容易出错：从最初编写代码的角度和阅读代码的人员的角度来看。如果表达式的子元素不遵循相同的模式，则尤其如此。

我不确定这MatchesSecondaryFilterIfPresent()是组合的最佳名称吗？但是没有比这更好的了。

尽管在C＃中，代码不是非常面向对象的。它使用的是静态方法，看起来像静态字段（例如repo）。通常认为，静态变量使您的代码难以重构且难以测试，同时又阻碍了可重用性，并且提出了一个问题：与诸如面向对象的构造相比，此类静态用法的可读性和可维护性较低。

您应该将此代码转换为更面向对象的形式。当您这样做时，您会发现在适当的地方放置了用于比较对象，字段等的代码。您然后可能会要求对象进行自我比较，这将使if语句大为简化。简单的比较请求（例如if ( a.compareTo (b) ) { }，可能包括所有字段比较。）

C＃具有一组丰富的接口和系统实用程序，用于对对象及其字段进行比较。除了显而易见的.Equals方法，对于初学者来说，看看IEqualityComparer，IEquatable和公用事业一样System.Collections.Generic.EqualityComparer.Default。

后者绝对是首选，我以第一种方式看过案例，并且几乎总是无法阅读。我犯了第一种方法的错误，并被要求将其更改为谓词方法。

我想说的是，如果您添加一些空格以提高可读性和一些注释来帮助读者了解较为晦涩的部分，则两者大致相同。

切记：好的注释可以告诉读者您在编写代码时的想法。

通过进行如我建议的更改，我可能会采用前一种方法，因为它不太混乱和分散。子例程调用就像脚注：它们提供有用的信息，但会干扰阅读流程。如果谓词更复杂，那么我会将它们分解为单独的方法，以便可以将其包含的概念构建为可理解的块。

好吧，如果您想重用某些部分，最好将它们分离成单独的正确命名的函数。
即使您可能永远不会重用它们，这样做也可以使您更好地构造条件，并给它们加上描述其含义的标签。

现在，让我们看一下您的第一个选择，并承认，缩进和换行既不是所有有用的东西，也不是条件构造的那么好：

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal) {
    return propVal.PropertyId == context.Definition.Id && !repo.ParentId.HasValue
        || repo.ParentId == propVal.ParentId
        && propVal.SecondaryFilter.HasValue == context.SecondaryFilter.HasValue
        && (!propVal.SecondaryFilter.HasValue || propVal.SecondaryFilter.Value == context.SecondaryFilter.Value);
}

第一个绝对可怕。您一直在使用|| 在同一行上有两件事；这可能是代码中的错误，也可能是混淆代码的意图。

    return (   (   propVal.PropertyId == context.Definition.Id
                && !repo.ParentId.HasValue)
            || (   repo.ParentId == propVal.ParentId
                && (   (   propVal.SecondaryFilter.HasValue
                        && context.SecondaryFilter.HasValue 
                        && propVal.SecondaryFilter.Value == context.SecondaryFilter)
                    || (   !context.SecondaryFilter.HasValue
                        && !propVal.SecondaryFilter.HasValue))));

这至少是经过适当格式化的一半（如果格式化很复杂，那是因为if条件很复杂），并且您至少有机会弄清楚其中是否有任何废话。与您格式化的垃圾相比，还有其他更好的选择。但是您似乎只能做极端：要么完全弄乱if语句，要么四个完全没有意义的方法。

注意（cond1 && cond2）|| （！cond1 && cond3）可以写成

cond1 ? cond2 : cond3

这样可以减少混乱。我会写

if (propVal.PropertyId == context.Definition.Id && !repo.ParentId.HasValue) {
    return true;
} else if (repo.ParentId != propVal.ParentId) {
    return false;
} else if (propVal.SecondaryFilter.HasValue) {
    return (   context.SecondaryFilter.HasValue
            && propVal.SecondaryFilter.Value == context.SecondaryFilter); 
} else {
    return !context.SecondaryFilter.HasValue;
}

我不喜欢这些解决方案，它们既难以推理，也难以阅读。仅为较小的方法而提取较小的方法并不总是可以解决问题。

理想情况下，我认为您应该在元编程上比较属性，因此您不必定义新方法，也不必每次都想比较一组新属性时是否分支。

我不确定c＃，但是在javascript中，这种方法会更好，并且至少可以替换MatchesDefinitionId和MatchesParentId

function compareContextProp(obj, property, value){
  if(obj[property])
    return obj[property] == value
  return false
}