dotnet-skills

Guidelines for writing TUnit tests in .NET, including setup, assertions, async testing, and best practices. Use when writing unit tests with TUnit framework, setting up TUnit in a .NET project, or migrating from other test frameworks to TUnit.

Hosted services, background jobs, outbox patterns, and graceful shutdown handling for ASP.NET Core applications. Includes patterns for reliable job processing, distributed systems, and lifecycle management. Use when implementing background processing in ASP.NET Core applications, handling outbox patterns for reliable message delivery, or managing graceful service shutdown.

Design stable, compatible public APIs using extend-only design principles. Manage API compatibility, wire compatibility, versioning, naming conventions, parameter ordering, and return types for NuGet packages and distributed systems. Use when designing public APIs for NuGet packages or libraries, making changes to existing public APIs, planning wire format changes for distributed systems, or reviewing pull requests for breaking changes.

Write modern, high-performance C# code using records, pattern matching, value objects, async/await, Span<T>/Memory<T>, and best-practice API design patterns. Emphasizes functional-style programming with C# 12+ features. Use when writing new C# code or refactoring existing code, designing public APIs for libraries or services, optimizing performance-critical code paths, or building async/await-heavy applications.

Choosing the right concurrency abstraction in .NET - from async/await for I/O to Channels for producer/consumer to Akka.NET for stateful entity management. Covers both high-level abstractions and low-level synchronization primitives. Use when deciding how to handle concurrent operations in .NET, evaluating whether to use async/await, Channels, or Akka.NET, or managing state across multiple concurrent entities.

Design .NET types for performance. Covers struct vs class decision matrix, sealed by default, readonly structs, ref struct and Span/Memory selection, FrozenDictionary, ValueTask, and collection return types. Use when designing new types and APIs, reviewing code for performance issues, choosing between class, struct, and record, or working with collections and enumerables.

Building accessible .NET UI. SemanticProperties, ARIA, AutomationPeer, testing tools per platform.

Adding analyzer packages to a project. Nullable, trimming, AOT compat analyzers, severity config.

Adding CI/CD to a .NET project. GitHub Actions vs Azure DevOps detection, workflow templates.

Adding test infrastructure to a .NET project. Scaffolds xUnit project, coverlet, layout.

Configuring .NET build/test in Azure DevOps. DotNetCoreCLI task, Artifacts, test results.

Designing composable Azure DevOps YAML pipelines. Templates, variable groups, multi-stage, triggers.

Publishing .NET artifacts from Azure DevOps. NuGet push, containers to ACR, pipeline artifacts.

Using ADO-exclusive features. Environments, approvals, service connections, classic releases.

Working with .NET, C#, ASP.NET Core, or related frameworks. Routes to specialist skills.

Generating or modifying .NET code. Common agent mistakes: async, NuGet, deprecated APIs, DI.

Designing AOT-first apps. Source gen over reflection, AOT-safe DI, serialization, factories.

AOT-compiling for WebAssembly. Blazor/Uno WASM AOT, size vs speed, lazy loading, Brotli.

Generating API documentation. DocFX setup, OpenAPI-as-docs, doc-code sync, versioned docs.

Implementing API auth. Identity, OAuth/OIDC, JWT bearer, passkeys (WebAuthn), CORS, rate limiting.

Detecting API changes in CI. PublicApiAnalyzers, Verify snapshots, breaking change enforcement.

Versioning HTTP APIs. Asp.Versioning.Http/Mvc, URL segment, header, query string, sunset.

Organizing APIs at scale. Vertical slices, request pipelines, caching, error handling, idempotency.

Using artifacts output layout. UseArtifactsOutput, ArtifactsPath, impact on CI and Docker.

Using .NET Aspire. AppHost orchestration, service discovery, components, dashboard, health checks.

Writing benchmarks. BenchmarkDotNet setup, memory diagnosers, baselines, result analysis.

Adding auth to Blazor. AuthorizeView, CascadingAuthenticationState, Identity UI, per-model flows.

Building Blazor components. Lifecycle, state management, JS interop, EditForm validation, QuickGrid.

Building Blazor apps. Hosting models, render modes, routing, streaming rendering, prerender.

Testing Blazor components. bUnit rendering, events, cascading params, JS interop mocking.

Interpreting MSBuild output, NuGet errors, or analyzer warnings. Error codes, CI drift fixes.

Diagnosing slow builds or incremental failures. Binary logs, parallel builds, restore.

Using producer/consumer queues. Channel<T>, bounded/unbounded, backpressure, drain patterns

Gating CI on perf regressions. Automated threshold alerts, baseline tracking, trend reports.

Structuring CLI app layers. Command/handler/service separation, clig.dev principles, exit codes.

Choosing CLI output format. AOT vs framework-dependent, RID matrix, single-file, dotnet tool.

Publishing to package managers. Homebrew, apt/deb, winget, Scoop, Chocolatey manifests.

Releasing CLI tools. GitHub Actions build matrix, artifact staging, Releases, checksums.

Deploying .NET containers. Kubernetes probes, Docker Compose for local dev, CI/CD integration.

Containerizing .NET apps. Multi-stage Dockerfiles, SDK container publish (.NET 8+), rootless.