标签: cyclomatic-complexity

LINQ和Lambda表达式是否会降低圈复杂度？只是很好奇,因为当VS分析器增加时,CodeRush实际上显示了cc的减少.

我们有这个代码,排序:

private void InitializeEvents()
{
    this.Event1 += (s,e) => { };
    this.Event2 += (s,e) => { };
    this.Event3 += (s,e) => { };
    this.Event4 += (s,e) => { };
    this.Event5 += (s,e) => { };
    this.Event6 += (s,e) => { };
    this.Event7 += (s,e) => { };
    this.Event8 += (s,e) => { };
    this.Event9 += (s,e) => { };
    this.Event10 += (s,e) => { };
    this.Event11 += (s,e) => { };
    this.Event12 += (s,e) => { };
    this.Event13 += (s,e) …

关于什么是循环复杂性已经存在一个问题？

然而,还有另一个称为"必要的循环复杂性"的术语.

这两个代码指标之间有什么区别和相似之处？他们的典型接受价值是什么？此外,我了解到,为了理解代码,Essential Cyclomatic Complexity是一个更相关的指标.而从实施的角度来看,Cyclomatic Complexity是最相关的.如果是这样,为什么？

现在我正在开发一个Web应用程序,它从一个有可能返回null结果的数据库中接收大量数据.当经历应用程序的圈复杂度时,许多函数的权重在10-30之间.大多数具有高数字的函数有很多类似于以下的行:

If Not oraData.IsDBNull(4) Then row("Field") = oraData.GetString(4)

这引出了我的问题,试图降低这些数字的最佳方法是什么？现在我正在考虑将大部分功能都放在10以下.

是否有可用于Java的工具可以自动确定给定Java代码的圈复杂度？我在线寻找工具,还没有找到.

我正在开发一个从Excel文件中提取数据的应用程序(我无法访问实际的数据库),并且我编写了一个方法,它具有从Excel电子表格中提取数据的唯一功能,如下所示.

private IEnumerable<SMEntity> ExtractSMData(List<MSExcel.Range> SMData)
{
    List<SMEntity> SMEntities = new List<SMEntity>();

    foreach (MSExcel.Range Row in SMData)
    {
        SMEntity entity = new SMEntity();
        entity.IncidentNumber = Row.get_Range("K1").get_Value();
        entity.SRNumber = Row.get_Range("L1").get_Value();
        entity.SRCategory = Row.get_Range("M1").get_Value();
        entity.SiebelClientCall = EntityConversions.DateTimeConversion(Row.get_Range("N1").get_Value());
        entity.SiebelOpenedDate = EntityConversions.DateTimeConversion(Row.get_Range("O1").get_Value());
        entity.IncidentOpenDate = EntityConversions.DateTimeConversion(Row.get_Range("P1").get_Value());
        entity.PickedUpBeforeClient = Row.get_Range("Q1").get_Value().ToString().ToLowerCase() == "no" ? false : true;
        entity.OutageStartTime = EntityConversions.DateTimeConversion(Row.get_Range("R1").get_Value());
        entity.DetectionPoint = EntityConversions.DateTimeConversion(Row.get_Range("S1").get_Value());
        entity.SecondsToDetection = EntityConversions.ConvertDetectionTimeToInt(Row.get_Range("T1").get_Value());
        entity.OutageEndTime = EntityConversions.DateTimeConversion(Row.get_Range("U1").get_Value());
        entity.MTTR = EntityConversions.ConvertMTTRStringToInt(Row.get_Range("V1").get_Value());
        entity.RepairedOnTime = Row.get_Range("W1").get_Value().ToString().ToLowerCase() == "no" ? false : true;
        SMEntities.Add(entity);
    }

    return SMEntities;
}

我运行代码分析(我使用的是Visual Studio …

我想开始衡量 Michael Feathers 所说的代码动荡，即churn vs. complex。

为此，我需要衡量 C++ 或 Java 文件的复杂性。所以我找到了几个测量圈复杂度（CC）的工具。他们都在功能或方法级别很好地测量了 CC。但是，我需要一个文件级别的指标，而他们在那里做得并不好。一个工具只返回文件中所有方法复杂度的平均值，另一个工具将整个文件视为一个巨大的方法，即计算整个文件中的所有决策点。

所以我做了一些研究，发现 McCabe 仅根据模块来定义 CC——他们将模块定义为函数——而不是文件（参见本演示文稿的幻灯片 20 和 30 ）。我认为这是有道理的。

所以现在我要尝试弄清楚如何表示文件复杂性。我的想法是我应该对该文件使用最大方法 CC 。

关于这种方法的任何想法或任何其他建议？

谢谢！

肯

对于下面的代码,sonarqube计算方法圈复杂度为9

String foo() {
    if (cond1) return a;
    if (cond2) return b;
    if (cond3) return c;
    if (cond4) return d;
    return e;
}

据我所知,根据计算规则http://docs.sonarqube.org/display/SONAR/Metrics+-+Complexity,9的复杂性是正确的.因此该方法的复杂性是= 4(如果)+ 4(返回)+ 1(方法)= 9

如果我有一个退出点,这种复杂性可以降低.

String foo() {
    String temp;
    if (cond1) { 
        temp = a;
    } else if (cond2) {
        temp = b;
    } else if (cond3) { 
        temp = c;
    } else if (cond4) {
        temp = d;
    } else {
        temp = e;
    }
    return temp;
}

我相信这个代码比以前的版本更混乱,更难以理解,我觉得拥有返回保护条件的方法是一种更好的编程习惯.那么有什么理由可以考虑返回语句来计算圈复杂度？可以改变计算逻辑,使其不会促进单一退出点.

什么是必要的,设计复杂性,扩展的圈复杂度,圈复杂度之间的差异？

我正在使用IntelliJ IDEA插件检查这些指标.

我有一个相对较大的Python项目，并且没有任何圈复杂性工具作为自动化测试和部署过程的一部分。

Python中的圈复杂度工具有多重要？您或您的项目使用它们并发现它们有效吗？我想要一个很好的前后故事，如果有人的话，那么我们可以从答案中去除一些主观性（即，在我们也没有cyclo-comp工具之前，以及在介绍它之后，好事A发生了，坏事B发生了，等等）。对于这种类型的问题，还有很多其他的一般答案，但是我没有找到特别适合Python项目的答案。

我最终试图确定将它添加到我们的流程中是否值得，以及哪种特定的度量标准和工具/库最适合大型Python项目。我们的主要目标之一是长期维护。