Crap Analysis

Crap Analysis is a development skill for measuring C# code complexity with CRAP metrics, covering cyclomatic complexity, code coverage analysis, and refactoring prioritization

What Is This?

Overview

CRAP Analysis evaluates C# code quality by calculating the Change Risk Analysis and Predictions (CRAP) metric, which combines cyclomatic complexity with code coverage data. This metric is designed to identify which methods in your codebase pose the highest risk during refactoring and ongoing maintenance. The CRAP score helps developers prioritize which code sections need immediate attention based on both their complexity and the extent to which they are covered by automated tests.

The CRAP metric originated from Bob Martin’s work on code quality assessment and has since become a widely recognized standard for identifying problematic code. A high CRAP score indicates code that is both complex and poorly tested, making it a prime candidate for refactoring. By analyzing these metrics, teams can make data-driven decisions about where to invest refactoring effort, rather than relying on intuition or subjective opinions.

The CRAP score is calculated using the formula:
CRAP = comp² × (1 - cov)³ + comp,
where comp is cyclomatic complexity and cov is code coverage (as a decimal). This formula ensures that both high complexity and low coverage contribute exponentially to the risk score, highlighting the most dangerous code.

Who Should Use This

C# developers, technical leads, and QA engineers who want to identify high-risk code sections and prioritize refactoring efforts based on objective metrics rather than subjective assessments will benefit from CRAP Analysis. It is especially useful for teams maintaining large or legacy codebases, where understanding code risk is critical for planning and resource allocation. Architects and engineering managers can also use CRAP metrics to communicate technical debt and risk to non-technical stakeholders.

Why Use It?

Problems It Solves

Legacy codebases often contain complex methods with minimal test coverage, creating maintenance bottlenecks and increasing the risk of bugs. CRAP Analysis identifies exactly which methods need attention, preventing teams from wasting effort on low-risk code while ignoring dangerous complexity. This targeted approach reduces technical debt systematically and improves overall code health.

By focusing on the intersection of complexity and coverage, CRAP Analysis helps teams avoid the common pitfall of refactoring code that is already well-tested or simple. It also provides a quantifiable way to track improvements in code quality over time, supporting continuous improvement initiatives.

Core Highlights

CRAP metrics combine cyclomatic complexity and code coverage into a single risk score. The analysis automatically identifies methods exceeding safe complexity thresholds, such as a CRAP score above 30. Coverage data integration reveals which complex code lacks adequate testing, making it easier to spot high-risk areas. Prioritization recommendations help teams tackle the highest-impact refactoring opportunities first, ensuring that limited resources are used effectively.

CRAP Analysis can be integrated with reporting tools to visualize risk across projects, and its results can be shared with stakeholders to justify technical debt reduction efforts.

How to Use It?

Basic Usage

var analyzer = new CrapAnalyzer();
var results = analyzer.AnalyzeAssembly("MyApp.dll");
var highRiskMethods = results
  .Where(m => m.CrapScore > 30)
  .OrderByDescending(m => m.CrapScore);

Real-World Examples

Example one: Analyzing a legacy payment processing module to identify which methods need refactoring before adding new features.

var paymentModule = analyzer.AnalyzeNamespace(
  "MyApp.Payments");
var criticalMethods = paymentModule
  .Where(m => m.CrapScore > 25 && m.Coverage < 0.5);

Example two: Generating a report showing CRAP scores across an entire solution to present to stakeholders.

var solutionAnalysis = analyzer.AnalyzeSolution(
  "MySolution.sln");
var report = new CrapReport(solutionAnalysis);
report.ExportToCsv("crap-analysis.csv");

Advanced Tips

Filter results by namespace or class to focus analysis on specific modules rather than analyzing entire solutions at once. Integrate CRAP analysis into your CI/CD pipeline to track metric trends over time and catch complexity increases early. Use historical CRAP data to monitor the effectiveness of refactoring efforts and to set team goals for technical debt reduction.

When to Use It?

Use Cases

Use CRAP Analysis before starting a major refactoring initiative to identify which methods will provide the most value when improved. Apply it during code review processes to objectively assess whether a method’s complexity justifies its test coverage. Run it periodically on legacy systems to track technical debt reduction progress. Integrate it into pull request checks to prevent new high-CRAP methods from entering the codebase.

Related Topics

CRAP Analysis complements static analysis tools like SonarQube and works alongside code coverage tools such as OpenCover and Coverlet for comprehensive code quality assessment. It can also be used in conjunction with architectural review processes and other code metrics like maintainability index.

Important Notes

While CRAP Analysis provides actionable insights for prioritizing code refactoring, it relies on accurate complexity and coverage data from your C# environment. Results may vary based on the quality of coverage reports and the granularity of analysis. Integrating CRAP metrics into your workflow requires some setup and understanding of both your codebase and supporting tools.

Requirements

• Access to the C# source code or compiled assemblies to analyze
• Availability of code coverage reports generated by tools such as OpenCover or Coverlet
• .NET runtime and compatible build environment for running the analyzer
• Sufficient permissions to read code files and coverage data outputs

Usage Recommendations

• Ensure code coverage reports are up-to-date and accurately reflect the current state of your tests
• Run CRAP Analysis regularly, especially after significant code changes or before major releases
• Use namespace or class-level filters to focus on high-impact modules rather than analyzing the entire codebase indiscriminately
• Integrate CRAP Analysis into CI/CD pipelines to automate risk detection and track trends over time
• Review methods with borderline CRAP scores to determine if targeted improvements can reduce risk efficiently

Limitations

• Only analyzes methods for which both cyclomatic complexity and code coverage data are available; incomplete data may lead to gaps in reporting
• Does not assess non-method code elements such as properties, fields, or global functions
• Does not provide automated code fixes or refactorings—identifies risk but leaves remediation to developers
• May not fully account for external dependencies or dynamic code paths not exercised by tests