Seams.Analyzers 2.0.2

Seams.Analyzers

A Roslyn analyzer library that detects code patterns blocking "seams" in legacy code, based on Michael Feathers' Working Effectively with Legacy Code.

Use Cases

1. AI-Assisted Development

When SEAM rules are configured as warnings or errors, AI coding assistants (GitHub Copilot, Claude, Cursor, Windsurf, etc.) read build failures and adapt their code generation to avoid untestable patterns.

How It Works

Developer Request → AI Generation → Analyzer Feedback → AI Iteration → Testable Code

1. AI generates code with a hard dependency (e.g., new EmailService())
2. Build fails with SEAM001: Direct instantiation of concrete type 'EmailService'
3. AI reads this feedback and regenerates using dependency injection
4. Resulting code is testable from the start

Setup

<PropertyGroup>
  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>

2. Legacy Code Refactoring

When working with legacy code, this analyzer helps you identify where to create seams so you can test a class. By detecting the 18 anti-patterns that block testability, you can systematically refactor code to introduce dependency injection points, extract interfaces, and break hard dependencies—making previously untestable code testable.

What are Seams?

A seam is a place where you can alter behavior in your program without editing in that place. Seams are essential for testing because they allow you to substitute dependencies, mock behaviors, and isolate code under test.

This analyzer identifies 18 anti-patterns (SEAM001-SEAM018) across 5 categories that hinder testability by blocking seams.

Installation

dotnet add package Seams.Analyzers

Or via Package Manager:

Install-Package Seams.Analyzers

Diagnostic Rules

Default Severity Levels

Not all rules are enabled by default. This follows the Principle of Least Astonishment (POLA) - rules that may produce many warnings in typical codebases are disabled by default to avoid overwhelming users on first installation.

To enable disabled rules, add to your .editorconfig:

# Enable specific disabled rules
dotnet_diagnostic.SEAM002.severity = suggestion
dotnet_diagnostic.SEAM004.severity = suggestion
dotnet_diagnostic.SEAM008.severity = suggestion
dotnet_diagnostic.SEAM009.severity = suggestion
dotnet_diagnostic.SEAM010.severity = suggestion
dotnet_diagnostic.SEAM011.severity = suggestion

Direct Dependencies

Static Dependencies

Inheritance Blockers

Global State

Infrastructure Dependencies

Configuration

Suppress diagnostics or exclude specific types via .editorconfig:

# Disable a rule entirely
dotnet_diagnostic.SEAM001.severity = none

# Exclude specific types from SEAM001
dotnet_code_quality.SEAM001.excluded_types = T:MyNamespace.AllowedFactory

# Exclude specific methods from SEAM004
dotnet_code_quality.SEAM004.excluded_methods = M:System.Console.WriteLine

# Exclude namespaces from SEAM009
dotnet_code_quality.SEAM009.excluded_namespaces = MyNamespace.Internal

# Set complexity threshold for SEAM011 (default: 50)
dotnet_code_quality.SEAM011.complexity_threshold = 100

Example

public class OrderService
{
    // SEAM001: Direct instantiation creates hard dependency
    private readonly EmailService _emailService = new EmailService();

    // Better: Inject the dependency
    private readonly IEmailService _emailService;

    public OrderService(IEmailService emailService)
    {
        _emailService = emailService;
    }
}

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

Acknowledgments

This project is inspired by Michael Feathers' book Working Effectively with Legacy Code. The concept of "seams" as places where you can alter program behavior without editing in that place comes directly from his work. Thank you to Michael Feathers for providing such valuable insights into making legacy code testable.

License

This project is licensed under the MIT License - see the LICENSE file for details.