如何使用NDepend计算方法的Response指标？及嵌套函数调用产生的源代码行数统计方案咨询

Hey there! Let's tackle your two questions about code metrics and call chain line counting—here's what I know:

First off, in NDepend, the Response metric for a method refers to how many distinct other methods call it (essentially its "incoming call count"). Here's how you can calculate it easily:

• Fire up NDepend and load your project solution.
• You have two main approaches:
  1. Using CQLinq (Code Query LINQ) (the most flexible way):
     Open the NDepend query editor and paste this custom query, replacing YourTargetMethodName with your actual method name:

     from m in Methods
     where m.Name == "YourTargetMethodName"
     select new {
        TargetMethod = m,
        ResponseCount = m.MethodsCallingMe.Count()
     }
     

     Run the query, and the ResponseCount value will be your method's Response metric. If you want to exclude calls from test projects (for example), add && !m.DeclaringType.IsInTestProject to the where clause.
  2. Using the built-in metrics view:
     Navigate to the Code Metrics or Dashboard section, locate your target method, and look for the metric labeled "Number of Methods Calling Me"—this is exactly the Response metric you're after.

Absolutely! This requires analyzing method call chains and summing line counts based on how many times each method is invoked (like your examples where repeated calls add their lines again). Here are a few solid solutions:

Option 1: Custom CQLinq Query in NDepend #

NDepend can track call chains and line counts together. To replicate your example logic (summing lines for every invocation, including repeats), use this query:

// Target the method you want to analyze
let targetMethod = Methods.WithName("Function1").Single()

// Get all method invocations triggered directly or indirectly by the target method
let allInvokedMethods = from m in Methods
                        from inv in m.Invocations
                        where inv.ParentMethod.IsDescendantOf(targetMethod) || inv.ParentMethod == targetMethod
                        select inv.TargetMethod

// Calculate total lines: target method's lines + sum of lines for every invoked method instance
let totalLOC = targetMethod.NbLinesOfCode + allInvokedMethods.Sum(m => m.NbLinesOfCode)

select new {
   TargetMethod = targetMethod,
   TotalLineCount = totalLOC
}

This will give you results matching your examples: for instance, if Function1 calls Function2 twice, it adds 20 lines twice, leading to the 70 total in your third example.

Option 2: Build a Custom Analyzer with Roslyn #

If you prefer a do-it-yourself approach, use Microsoft's Roslyn (.NET Compiler API):

• Load your project into Roslyn's syntax tree parser.
• Locate your target method's syntax node.
• Recursively traverse all invocation statements in the method (and nested calls) to track every method being called.
• For each invoked method, calculate its line count using the start/end line numbers of its syntax node.
• Sum the counts, including repeats for multiple invocations of the same method.

Option 3: Use Other Static Analysis Tools #

Tools like JetBrains Rider/ReSharper let you visualize call chains, and you can create custom macros or plugins to sum line counts. SonarQube also supports custom rules that can be extended to implement this line-counting logic.

To match your examples exactly:

In Example 3, Function1 calls Function2 twice and Function3 once. The total line count is 10 (Function1) + 20×2 (Function2 calls) + 20 (Function3) = 70—all the above solutions can handle this repeated-count logic.

内容的提问来源于stack exchange，提问作者Dirk