# .NET CI Quality Checklist

Use this checklist when setting up or auditing quality gates for a .NET repository.

## Foundation Checklist

### Repository Configuration

- [ ] Repo-root `.editorconfig` exists and owns formatting, naming, and analyzer severity
- [ ] `Directory.Build.props` exists for shared MSBuild properties
- [ ] `EnableNETAnalyzers` is explicitly set to `true`
- [ ] `AnalysisLevel` is set to `latest` or a specific version
- [ ] `TreatWarningsAsErrors` policy is documented and applied consistently
- [ ] `.config/dotnet-tools.json` tracks local tool versions if tools are used

### Build Configuration

- [ ] Solution builds with `dotnet build -warnaserror`
- [ ] Build uses deterministic output settings for reproducibility
- [ ] SDK version is pinned in `global.json` if consistency is required
- [ ] Build logs no analyzer suppressions without documented reason

## Formatting and Style

### dotnet format

- [ ] `dotnet format --verify-no-changes` runs in CI
- [ ] Format failures block PR merge
- [ ] Format rules are in `.editorconfig`, not scattered across IDE settings
- [ ] Whitespace, indentation, and naming rules are explicit

### Optional Formatter

- [ ] If CSharpier is used, ownership split with `dotnet format` is documented
- [ ] Formatter choice is documented in `AGENTS.md`
- [ ] Pre-commit hooks or CI enforce the chosen formatter

## Static Analysis

### SDK Analyzers

- [ ] `Microsoft.CodeAnalysis.NetAnalyzers` is enabled (default in .NET 5+)
- [ ] CA rules are configured in `.editorconfig` with explicit severity
- [ ] `CA1502` (cyclomatic complexity) threshold is set if complexity matters
- [ ] `CA1505` (maintainability index) is enabled for maintainability gates
- [ ] `CA1506` (class coupling) is enabled for architecture guidance

### Third-Party Analyzers

- [ ] Analyzer packages serve distinct purposes (no redundant overlap)
- [ ] `StyleCopAnalyzers` configured if naming/documentation rules needed
- [ ] `Roslynator` configured if broader Roslyn rules needed
- [ ] `Meziantou.Analyzer` configured if security/performance rules needed
- [ ] Framework-specific analyzers installed (xUnit, MSTest, or TUnit)

### Analyzer Configuration

- [ ] All analyzer rules have explicit severity in `.editorconfig`
- [ ] Suppressed rules are documented with reason
- [ ] `stylecop.json` is minimal and does not duplicate `.editorconfig`
- [ ] No analyzer warnings are silently ignored

## Testing

### Test Runner

- [ ] Test runner model is documented: VSTest or Microsoft.Testing.Platform
- [ ] Test command is explicit in `AGENTS.md` and CI
- [ ] Tests pass locally and in CI with same command
- [ ] Test filters work correctly for focused and broad test runs

### Test Quality

- [ ] Unit tests exist for business logic
- [ ] Integration tests exist for external dependencies
- [ ] Test naming follows consistent convention
- [ ] Test organization matches production code structure

## Code Coverage

### Coverage Collection

- [ ] Coverage driver matches test runner:
  - VSTest: `coverlet.collector` or `--collect:"XPlat Code Coverage"`
  - MTP: `coverlet.MTP` or MSTest SDK coverage extensions
- [ ] Coverage output format is specified (Cobertura recommended)
- [ ] Coverage artifacts are generated in CI

### Coverage Reporting

- [ ] ReportGenerator or equivalent produces human-readable reports
- [ ] Coverage report is uploaded as CI artifact
- [ ] Coverage thresholds are documented if enforced
- [ ] Coverage badge is generated if displayed in README

## Architecture and Security

### Architecture Tests

- [ ] Architecture test project exists if layer boundaries matter
- [ ] NetArchTest or ArchUnitNET is configured
- [ ] Dependency rules are explicit and tested
- [ ] Architecture tests run in CI

### Security Scanning

- [ ] CodeQL is configured for GitHub repositories (with hosting caveat noted)
- [ ] Security advisories are monitored via Dependabot or equivalent
- [ ] Secrets scanning is enabled
- [ ] Container scanning if Docker is used

## Advanced Quality Gates

### Mutation Testing

- [ ] Stryker.NET is configured for critical libraries
- [ ] Mutation testing runs on schedule (not every PR)
- [ ] Mutation score threshold is documented
- [ ] Mutation reports are reviewed periodically

### Complexity Management

- [ ] `CA1502` threshold is set for max cyclomatic complexity
- [ ] `AGENTS.md` documents:
  - `file_max_loc`
  - `type_max_loc`
  - `function_max_loc`
  - `max_nesting_depth`
- [ ] Complex methods are flagged in code review
- [ ] Refactoring is prioritized for high-complexity code

## CI Workflow

### Workflow Structure

- [ ] Quality workflow triggers on push to main and PRs
- [ ] Jobs are ordered logically: restore, build, test, format, analyze
- [ ] Independent jobs run in parallel where possible
- [ ] Dependent jobs use `needs` to express dependencies
- [ ] Workflow uses caching for NuGet packages

### Workflow Reliability

- [ ] Workflow uses pinned action versions (not `@main` or `@latest`)
- [ ] .NET SDK version is explicit in `setup-dotnet`
- [ ] Environment variables reduce CLI noise (`DOTNET_NOLOGO`, `DOTNET_CLI_TELEMETRY_OPTOUT`)
- [ ] Timeouts are set for long-running jobs
- [ ] Artifacts are uploaded for reports and coverage

### Workflow Maintenance

- [ ] Workflow files are reviewed in PRs
- [ ] Workflow changes are tested in feature branches
- [ ] Deprecated actions are updated promptly
- [ ] Workflow documentation exists in `AGENTS.md` or `CONTRIBUTING.md`

## Documentation

### AGENTS.md Quality Section

- [ ] Exact `build` command is documented
- [ ] Exact `test` command is documented
- [ ] Exact `format` command is documented
- [ ] Exact `analyze` command is documented
- [ ] Exact `coverage` command is documented (if enabled)
- [ ] Test runner model is stated: VSTest or Microsoft.Testing.Platform
- [ ] Quality gate ownership is clear for each category

### Contributor Documentation

- [ ] Quality gate setup is documented in `CONTRIBUTING.md`
- [ ] Local quality check commands are documented
- [ ] Pre-commit hook setup is documented (if used)
- [ ] IDE configuration recommendations exist

## Verification Commands

Run these commands to verify quality gate setup:

```bash
# Verify formatting
dotnet format --verify-no-changes

# Verify build with warnings as errors
dotnet build -warnaserror

# Verify tests pass
dotnet test

# Verify coverage collection (VSTest)
dotnet test --collect:"XPlat Code Coverage"

# Verify analyzers run
dotnet build -p:EnforceCodeStyleInBuild=true

# Verify architecture tests (if configured)
dotnet test --filter "Category=Architecture"
```

## Common Issues Checklist

- [ ] No conflicting ownership between `dotnet format` and CSharpier
- [ ] No VSTest switches in Microsoft.Testing.Platform projects
- [ ] No `.runsettings` assumptions that break on MTP
- [ ] No analyzer packages that duplicate SDK analyzer rules
- [ ] No coverage drivers mismatched with test runner
- [ ] No hand-edited generated files that drift from source
- [ ] No quality gates that only run locally and skip CI
- [ ] No suppressed warnings without documented justification

## Sources

- [Overview of .NET source code analysis](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/overview)
- [Configuration files for code analysis rules](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/configuration-files)
- [dotnet format command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-format)
- [Code metrics values](https://learn.microsoft.com/en-us/visualstudio/code-quality/code-metrics-values?view=vs-2022)
- [GitHub Actions for .NET](https://docs.github.com/en/actions/use-cases-and-examples/building-and-testing/building-and-testing-net)

# .NET EditorConfig and CI Ownership

Use this reference when the repository needs one durable source of truth for formatting, naming, style, and analyzer severity.

## Ownership Rules

- repo-root lowercase `.editorconfig` is the default source of truth for .NET formatting, naming, code-style, and analyzer severity.
- nested `.editorconfig` files are allowed when they serve a clear subtree-specific purpose.
- `.globalconfig` is an exceptional fallback, not the normal repo setup.
- `Directory.Build.props`, `Directory.Build.targets`, or project files should own bulk switches such as:
  - `EnableNETAnalyzers`
  - `AnalysisLevel`
  - `TreatWarningsAsErrors`
  - runner selection such as `UseVSTest`
- the root `.editorconfig` should own per-rule severity and code-style detail.

## CI Rules

- `dotnet format` reads `.editorconfig`; use `dotnet format --verify-no-changes` in CI.
- `dotnet build -warnaserror` or the repo's equivalent should enforce analyzer severity.
- Coverage driver must match the runner:
  - VSTest: `coverlet.collector` or `--collect:"XPlat Code Coverage"`
  - Microsoft.Testing.Platform: `coverlet.MTP` or MSTest SDK coverage extensions
- Report generation is a separate step. Use ReportGenerator after coverage collection if humans need HTML, Markdown, or badges.

## Conflict Rules

- Do not let IDE-only settings, CI-only flags, and repo config disagree about the same rule.
- Do not write inline comments in `.editorconfig` values; they are not part of the current EditorConfig spec.
- Do not let `CSharpier` and `dotnet format` both own formatting unless the split is explicit and documented.
- Do not mix VSTest-only switches, filters, or `.runsettings` assumptions into Microsoft.Testing.Platform jobs.
- Keep `stylecop.json` for StyleCop behavior only; do not treat it as the repo-wide severity owner.

## Good AGENTS.md Signals for .NET

- exact `build`, `test`, `format`, `analyze`, and `coverage` commands
- exact test runner model: `VSTest` or `Microsoft.Testing.Platform`
- exact framework skill: `dotnet-xunit`, `dotnet-tunit`, or `dotnet-mstest`
- explicit statement that the repo-root `.editorconfig` is the analyzer source of truth

## Sources

- [dotnet format command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-format)
- [Configuration files for code analysis rules](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/configuration-files)
- [Overview of .NET source code analysis](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/overview)

# Recommended OSS .NET Quality Toolchain

Use this reference when a .NET repository needs an explicit, open-source-first quality stack for CI.
Each listed tool now has a dedicated skill folder, so use this page for selection and use the matching tool skill for installation and detailed setup.

Open/free policy for this catalog:

- everything listed here is open source or free to adopt locally
- `CodeQL` stays in the catalog with an explicit caveat because the hosted GitHub private-repo experience is not universally free

Install policy for this catalog:

- always verify first whether the tool is already present in `*.csproj`, `Directory.Build.*`, `.config/dotnet-tools.json`, or CI workflows
- prefer the repo's existing installation path over adding a second package, tool, or runner

## Baseline Stack

Use this baseline for most .NET repositories before adding anything exotic:

| Area | Tool | Skill | Why |
| --- | --- | --- | --- |
| Format and style | `dotnet format` | `dotnet-format` | Native CLI support, reads `.editorconfig`, supports verify-only mode in CI |
| Built-in static analysis | SDK analyzers / `Microsoft.CodeAnalysis.NetAnalyzers` | `dotnet-code-analysis` | First-party CA and IDE rules, enabled by default on modern .NET |
| Complexity and maintainability | `CA1502`/`CA1505`/`CA1506` | `dotnet-complexity` | Finds overly complex methods, low maintainability index, and excessive coupling |
| Analyzer config | repo-root `.editorconfig` | `dotnet-analyzer-config` | One durable source of truth for style and rule severity |
| Style and conventions | `StyleCopAnalyzers` | `dotnet-stylecop-analyzers` | Strong naming, layout, documentation, and consistency checks |
| General code quality | `Roslynator` | `dotnet-roslynator` | Broad Roslyn analyzer set and optional CLI |
| General code quality | `Meziantou.Analyzer` | `dotnet-meziantou-analyzer` | Design, usage, security, performance, and style rules |
| Coverage collection | `coverlet` | `dotnet-coverlet` | Cross-platform line, branch, and method coverage |
| Coverage reporting | `ReportGenerator` | `dotnet-reportgenerator` | Converts coverage artifacts into HTML, Markdown, Cobertura, badges, and more |

## Framework-Specific Additions

Pick the test-framework add-on that matches the repo:

| Framework | Tool | Skill | Why |
| --- | --- | --- | --- |
| xUnit | `xunit.analyzers` | `dotnet-xunit` | xUnit-specific correctness and usage rules |
| TUnit | built-in TUnit analyzers | `dotnet-tunit` | Compile-time guidance for signatures, attributes, and usage |
| MSTest | `MSTest.Analyzers` via `MSTest` / `MSTest.Sdk` | `dotnet-mstest` | MSTest-specific correctness and usage rules |

## High-Value Optional Gates

These tools are worth adding once the baseline is stable:

| Area | Tool | Skill | Why | Notes |
| --- | --- | --- | --- | --- |
| Mutation testing | `Stryker.NET` | `dotnet-stryker` | Verifies that tests actually catch faults | Best on libraries and critical domains, not every PR path |
| Architecture tests | `NetArchTest.Rules` | `dotnet-netarchtest` | Simple, fluent architectural rules in tests | Good for layered or clean architecture policies |
| Architecture tests | `ArchUnitNET` | `dotnet-archunitnet` | Richer architecture assertions across xUnit, MSTest, and TUnit | Heavier than NetArchTest but more expressive |
| Deep inspections and cleanup | `JetBrains ReSharper Command Line Tools` | `dotnet-resharper-clt` | Powerful ReSharper inspections plus cleanup profiles in CI or local runs | Free official JetBrains CLI package; keep shared policy in solution `.DotSettings` |
| Security scanning | `CodeQL` | `dotnet-codeql` | Deep GitHub-native query-based analysis | Open ecosystem with private-repo hosting caveats |
| Opinionated formatter | `CSharpier` | `dotnet-csharpier` | Fast one-style formatter for C# and XML | Use only if the repo wants a formatter owner beyond `dotnet format` |

## Complexity Strategy

There is no dominant open-source, CI-native .NET complexity suite that cleanly replaces NDepend.

For OSS-first repos, use a composite gate:

1. `CA1502` with an explicit threshold for excessive cyclomatic complexity.
2. Maintainability limits in `AGENTS.md`:
   - `file_max_loc`
   - `type_max_loc`
   - `function_max_loc`
   - `max_nesting_depth`
3. Architecture tests with NetArchTest or ArchUnitNET.
4. Coverage and mutation testing on critical paths.

For complex methods specifically, the primary built-in analyzer is `CA1502`.

If the repo later chooses a commercial metric product, treat it as an additional gate, not a replacement for the design and analyzer baseline.

## Suggested CI Order

```bash
dotnet restore
dotnet build MySolution.sln -warnaserror
dotnet test MySolution.sln --no-build
dotnet format MySolution.sln --verify-no-changes
```

## Agent Post-Change Flow

When an agent writes or refactors `.NET` code, do not stop after `dotnet test`.

Use the exact commands from `AGENTS.md`. The usual checked-in flow is:

1. `format`
2. `build`
3. `analyze`
4. focused `test`
5. broader `test`
6. `coverage` and report generation when configured
7. extra configured gates such as Roslynator, StyleCop, Meziantou, ReSharper CLT, architecture tests, CodeQL, CSharpier, or Stryker

Run only the gates the repo actually enabled.

Then add the runner-specific extras:

- VSTest coverage:

```bash
dotnet test MySolution.sln --collect:"XPlat Code Coverage"
```

- Microsoft.Testing.Platform coverage:

```bash
dotnet test MySolution.sln --coverlet
```

- Report generation:

```bash
reportgenerator -reports:"**/coverage.cobertura.xml" -targetdir:"artifacts/coverage" -reporttypes:"HtmlSummary;Cobertura"
```

- Mutation testing:

```bash
dotnet stryker
```

## Sources

- [dotnet format command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-format)
- [Overview of .NET source code analysis](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/overview)
- [Configuration files for code analysis rules](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/configuration-files)
- [CA1502: Avoid excessive complexity](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1502)
- [Code metrics values](https://learn.microsoft.com/en-us/visualstudio/code-quality/code-metrics-values?view=vs-2022)
- [StyleCopAnalyzers](https://github.com/DotNetAnalyzers/StyleCopAnalyzers)
- [Roslynator](https://github.com/JosefPihrt/Roslynator)
- [Meziantou.Analyzer](https://github.com/meziantou/Meziantou.Analyzer)
- [Coverlet](https://github.com/coverlet-coverage/coverlet)
- [ReportGenerator](https://github.com/danielpalme/ReportGenerator)
- [Stryker.NET](https://github.com/stryker-mutator/stryker-net)
- [NetArchTest](https://github.com/BenMorris/NetArchTest)
- [ArchUnitNET](https://github.com/TNG/ArchUnitNET)
- [ReSharper command line tools](https://www.jetbrains.com/help/resharper/ReSharper_Command_Line_Tools.html)
- [CleanupCode](https://www.jetbrains.com/help/resharper/CleanupCode.html)
- [InspectCode](https://www.jetbrains.com/help/resharper/InspectCode.html)
- [CodeQL code scanning](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql)
- [CSharpier](https://github.com/belav/csharpier)

# GitHub Actions Workflows for .NET Quality Gates

Use this reference when setting up or refining GitHub Actions CI pipelines for .NET quality enforcement.

## Minimal Quality Workflow

Start with this baseline workflow for most .NET repositories:

```yaml
name: .NET Quality

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore -warnaserror

      - name: Test
        run: dotnet test --no-build --verbosity normal

      - name: Format check
        run: dotnet format --verify-no-changes --verbosity diagnostic
```

## Full Quality Pipeline with Coverage

Extend the baseline with coverage collection and reporting:

```yaml
name: .NET Quality Full

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore --configuration Release -warnaserror

      - name: Test with coverage
        run: |
          dotnet test --no-build --configuration Release \
            --collect:"XPlat Code Coverage" \
            --results-directory ./coverage

      - name: Generate coverage report
        run: |
          dotnet tool install -g dotnet-reportgenerator-globaltool
          reportgenerator \
            -reports:"coverage/**/coverage.cobertura.xml" \
            -targetdir:"coverage/report" \
            -reporttypes:"HtmlSummary;Cobertura;MarkdownSummaryGithub"

      - name: Upload coverage report
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: coverage/report

      - name: Format check
        run: dotnet format --verify-no-changes

  analyze:
    runs-on: ubuntu-latest
    needs: build-and-test
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Restore
        run: dotnet restore

      - name: Build with analysis
        run: |
          dotnet build --no-restore --configuration Release \
            -p:EnforceCodeStyleInBuild=true \
            -p:TreatWarningsAsErrors=true
```

## Separate Jobs Pattern

For larger repositories, split quality gates into parallel jobs:

```yaml
name: .NET Quality Gates

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  DOTNET_NOLOGO: true

jobs:
  format:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'
      - run: dotnet restore
      - run: dotnet format --verify-no-changes

  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'
      - run: dotnet restore
      - run: dotnet build --no-restore -warnaserror

  test:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'
      - run: dotnet restore
      - run: dotnet build --no-restore
      - run: dotnet test --no-build

  analyze:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'
      - run: dotnet restore
      - name: Run analyzers
        run: |
          dotnet build --no-restore \
            -p:EnforceCodeStyleInBuild=true \
            -p:TreatWarningsAsErrors=true
```

## Coverage with Microsoft.Testing.Platform

For projects using Microsoft.Testing.Platform instead of VSTest:

```yaml
name: .NET MTP Coverage

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore

      - name: Test with MTP coverage
        run: |
          dotnet test --no-build \
            --coverlet-coverage \
            --coverlet-output-format cobertura \
            --coverlet-output ./coverage/

      - name: Generate report
        run: |
          dotnet tool install -g dotnet-reportgenerator-globaltool
          reportgenerator \
            -reports:"coverage/**/*.cobertura.xml" \
            -targetdir:"coverage/report" \
            -reporttypes:"HtmlSummary;Cobertura"

      - name: Upload coverage
        uses: actions/upload-artifact@v4
        with:
          name: coverage
          path: coverage/report
```

## Matrix Build for Multiple .NET Versions

Test against multiple .NET versions:

```yaml
name: .NET Multi-Version

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        dotnet-version: ['8.x', '9.x']
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET ${{ matrix.dotnet-version }}
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ matrix.dotnet-version }}

      - run: dotnet restore
      - run: dotnet build --no-restore
      - run: dotnet test --no-build
```

## CodeQL Security Scanning

Add GitHub CodeQL for security analysis:

```yaml
name: CodeQL

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 6 * * 1'

jobs:
  analyze:
    runs-on: ubuntu-latest
    permissions:
      security-events: write
      actions: read
      contents: read

    steps:
      - uses: actions/checkout@v4

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
        with:
          languages: csharp

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Build
        run: |
          dotnet restore
          dotnet build --no-restore

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v3
```

## Mutation Testing with Stryker

Add mutation testing for critical libraries:

```yaml
name: Mutation Testing

on:
  push:
    branches: [main]
  schedule:
    - cron: '0 4 * * 0'

jobs:
  mutate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Install Stryker
        run: dotnet tool install -g dotnet-stryker

      - name: Restore
        run: dotnet restore

      - name: Run Stryker
        run: dotnet stryker --reporter html --reporter progress
        working-directory: ./tests/MyProject.Tests

      - name: Upload mutation report
        uses: actions/upload-artifact@v4
        with:
          name: stryker-report
          path: '**/StrykerOutput/**'
```

## Architecture Tests Integration

Run architecture tests as part of the test job:

```yaml
name: Architecture Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  architecture:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore

      - name: Run architecture tests
        run: dotnet test --no-build --filter "Category=Architecture"
```

## ReSharper Command Line Tools

Use JetBrains InspectCode for deep analysis:

```yaml
name: ReSharper Inspection

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  inspect:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Install ReSharper CLT
        run: dotnet tool install -g JetBrains.ReSharper.GlobalTools

      - name: Restore
        run: dotnet restore

      - name: Run InspectCode
        run: |
          jb inspectcode MySolution.sln \
            --output=inspectcode-report.xml \
            --format=Xml \
            --severity=WARNING

      - name: Upload inspection report
        uses: actions/upload-artifact@v4
        with:
          name: inspectcode-report
          path: inspectcode-report.xml
```

## Caching Dependencies

Add caching to speed up workflow runs:

```yaml
- name: Cache NuGet packages
  uses: actions/cache@v4
  with:
    path: ~/.nuget/packages
    key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/Directory.Build.props') }}
    restore-keys: |
      ${{ runner.os }}-nuget-
```

## Sources

- [actions/setup-dotnet](https://github.com/actions/setup-dotnet)
- [actions/cache](https://github.com/actions/cache)
- [github/codeql-action](https://github.com/github/codeql-action)
- [dotnet test command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-test)
- [dotnet format command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-format)
- [ReportGenerator](https://github.com/danielpalme/ReportGenerator)
- [Stryker.NET](https://github.com/stryker-mutator/stryker-net)
- [ReSharper command line tools](https://www.jetbrains.com/help/resharper/ReSharper_Command_Line_Tools.html)