.NET Platform

Scan C# code for dependencies on clocks, files, environment settings, and other resources that make tests difficult. Get source locations, consistent counts, and suggested abstractions, interfaces or providers that let tests control those dependencies.

• Assessing testability before adding unit tests
• Finding hidden dependencies in legacy C# code
• Prioritizing dependencies to replace

Find language-specific guidance files for a code-testing pipeline. This reference catalog points agents to build and test commands, mocking patterns, common errors, and selected workflow examples across languages including .NET, Python, TypeScript, Go, and Java.

• Finding test guidance for a project's programming language
• Locating build commands and test framework guidance
• Finding mocking patterns and common error references

Convert NUnit 3 or 4 tests to MSTest v4 while keeping the existing target framework and test runner. The workflow translates assertions, test data, setup, and concurrency settings, then compares test counts and results.

• Migrating NUnit 3 or 4 tests to MSTest v4
• Preserving parameterized tests and test data
• Reviewing shared state and parallel execution during migration

Apply the System.Text.Json APIs introduced in .NET 11 to produce PascalCase JSON names and retrieve typed serialization metadata, the information used to convert objects. Create runnable examples and check metadata availability without exception-based probing.

• Produce PascalCase JSON property names
• Convert dictionary keys to PascalCase
• Retrieve typed serialization metadata without casts

Identify a .NET project’s test framework, project format, and execution platform: VSTest or Microsoft.Testing.Platform. Trace configuration imports and overrides to explain the result, including conflicting settings or differences between target frameworks.

• Determine whether tests execute on VSTest or MTP
• Identify the test framework from project configuration
• Investigate conflicting runner settings

Prepare .NET projects for Native AOT, compilation before execution, and trimming, which removes unused code. Use build warnings to guide type annotations, reflection changes, and source-generated JSON serialization, then check all target frameworks.

• Preparing a .NET project for Native AOT
• Resolving IL warnings from trimming analysis
• Adding annotations to reflection code

Choose and optionally run .NET test commands that match the project's SDK, test platform, and framework. Target specific tests, collect reports or diagnostics, and report execution results using syntax appropriate to the repository.

• Getting an exact test command for a repository
• Running a specific class, category, or target framework
• Collecting TRX reports, coverage, or diagnostic logs

Classify existing tests with standard tags for success cases, errors, boundaries, and other behaviors. Get a per-test mapping and distribution summary, or apply tags using supported framework syntax and verify compilation and test discovery.

• Comparing success-case and error-case test counts
• Adding standard tags to existing tests
• Reviewing the mix of boundary and integration tests

Install a .NET SDK, the tools used to build .NET projects, inside a project folder. Configure version selection and shared setup scripts to test previews or reproduce team and CI environments without changing the system installation.

• Trying a .NET preview without changing the system installation
• Pinning a project to a specific SDK version
• Creating repeatable setup scripts for teams and CI

Review custom dotnet new templates before publishing. Check required fields, parameter types and defaults, command name conflicts, and constraints, then receive findings grouped by severity with concrete fixes for errors and warnings.

• Checking template.json before publishing
• Investigating templates missing after installation
• Reviewing parameter types and default values

Refactor C#/.NET code through renaming, extraction, consolidation, and other structural changes while preserving behavior. Check compatibility beyond code references, including public APIs and serialized names, then validate with builds and relevant tests.

• Rename C# members and update their references
• Extract shared logic from duplicate code
• Reorganize code while preserving public API compatibility

Interpret .NET coverage reports, which show code exercised by tests, to explain missing coverage and stalled progress. Calculate the gains needed to reach a target and, when requested, combine coverage with complexity to rank risk.

• Explain Cobertura reports and partially covered conditions
• Find the code keeping coverage from improving
• Calculate line gains needed to reach a coverage target

Introduce nullable reference types into an existing C# project, making explicit which references may be null. Plan a staged migration, resolve compiler warnings, and clarify public API annotations while preserving runtime behavior.

• Adopting nullable reference types in an existing C# project
• Migrating a large codebase file by file
• Clarifying nullability in public APIs

Upgrade an existing .NET 8 project to .NET 9 by addressing build errors and compatibility changes. Update related packages, containers, and build pipelines, then verify the migration with clean builds and tests.

• Upgrading a project from net8.0 to net9.0
• Resolving new build errors and warnings after upgrading
• Reviewing ASP.NET Core and EF Core behavior changes

Interpret MSBuild performance summaries when ResolveProjectReferences appears unusually expensive. Separate time spent waiting for dependent projects from actual task work, then use task self-time rankings to identify a concrete optimization target.

• Investigating a high ResolveProjectReferences time
• Separating dependency wait time from task work
• Finding the actual bottleneck in a build log

Review explicitly selected tests or bounded pull request changes without running or editing code. Receive a follow-up decision for each test, A–F quality bands where assessable, evidence-based notes, and concrete suggestions for improvement.

• Reviewing a named test method
• Assessing every test in explicitly selected files
• Preparing per-test feedback for pull request changes

Upgrade MSTest v3 test projects to v4 by updating packages, adapting code to changed APIs, and checking execution behavior. It also helps resolve build errors and problems finding tests in CI after an upgrade.

• Upgrading an MSTest v3 project to v4
• Fixing compilation errors after an upgrade
• Updating custom TestMethodAttribute implementations

Find source files with no matching test references by parsing code without building or running tests. Produces a source-to-test map and suggested test locations, helping plan test additions across supported programming languages.

• List source files with no matching tests
• Choose locations for new test files
• Check source-to-test pairing after adding tests

Write and repair custom MSBuild targets, the steps that organize build tasks. Preserve existing build sequences, choose appropriate insertion points, distinguish returned results from rebuild checks, and register generated files for cleanup.

• Add custom steps to an existing build sequence
• Repair dependency settings that replace SDK build steps
• Correct stale results returned by query targets

Create a missing .NET test project or repair references and solution registration in an existing one. Follow the repository’s framework and package conventions, then verify the build or test entry point used by CI, the automated integration process.

• Set up a new .NET test project
• Repair tests missing from CI discovery
• Restore a reference to production code

Provide language-specific reference files for test analysis skills. The catalog helps agents recognize test methods, assertions, skipped tests, waiting patterns, setup and cleanup hooks, external dependencies, and tagging capabilities across different frameworks.

• Looking up assertion syntax for a test framework
• Checking skip annotations and setup or cleanup hooks
• Supporting test analysis across multiple languages

Make C# code testable when it directly uses static services such as time, files, or processes. It introduces existing abstractions or minimal wrappers, supplies dependency registration, and demonstrates tests with controlled substitutes for real resources.

• Introducing TimeProvider for time-dependent tests
• Testing file operations with MockFileSystem
• Wrapping Environment, Console, or Process calls

Compare two or more dotnet new templates using their installed options, features, and supported frameworks. Get a focused comparison table and a recommendation that explains which template best fits the project you want to build.

• Choosing between webapi and webapp
• Comparing blazor and blazorwasm
• Selecting console or worker for background processing

Create .NET projects from templates and align them with neighboring projects and centralized package versions. Validate options, connect projects in a solution, and build the result to check that the generated structure works.

• Creating a new .NET application from a template
• Combining an API, tests, and a library in one solution
• Adding a new project with centralized package versions