Dotnet Skills

Building .NET MAUI apps. Project structure, XAML/MVVM, platform services, current caveats.

Creating Mermaid diagrams for .NET. Architecture, sequence, class, deployment, ER, flowcharts.

Navigating .NET solution structure or build configuration. Analyzes .sln, .csproj, CPM.

Authoring Roslyn analyzers. DiagnosticAnalyzer, CodeFixProvider, CodeRefactoring, multi-version.

Creating a new .NET project. Generates solution with CPM, analyzers, editorconfig, SourceLink.

Designing classes or refactoring. SOLID, DRY, SRP with C# anti-patterns, fixes, compliance.

Deciding how to test .NET code. Unit vs integration vs E2E decision tree, test doubles.

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

Optimizing LINQ queries. IQueryable vs IEnumerable, compiled queries, deferred exec, allocations.

Authoring MSBuild targets, props, or conditions. Custom targets, incrementality, Build patterns.

Project has .csproj, global.json, or Directory.Build.props. Detects TFMs and SDK versions.

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

Reviewing C# for logic issues. Anti-patterns, common pitfalls, async misuse, DI mistakes.

Maintaining library compatibility. Binary/source compat rules, type forwarders, SemVer impact.

Building event-driven systems. Pub/sub, competing consumers, DLQ, sagas, delivery guarantees.

Managing .NET release lifecycle. NBGV versioning, SemVer, changelogs, pre-release, branching.

Handling secrets or sensitive configuration. User secrets, environment variables, rotation.

Designing log pipelines. Aggregation, structured queries, sampling, PII scrubbing, correlation.

Using System.CommandLine 2.0. Commands, options, SetAction, custom parsing, middleware, testing.

Write integration tests using .NET Aspire's testing facilities with xUnit. Covers test fixtures, distributed application setup, endpoint discovery, and patterns for testing ASP.NET Core apps with real dependencies. Use when writing integration tests for .NET Aspire applications, testing ASP.NET Core apps with real database connections, or verifying service-to-service communication in distributed applications.

Test email sending locally using Mailpit with .NET Aspire. Captures all outgoing emails without sending them. View rendered HTML, inspect headers, and verify delivery in integration tests. Use when testing email delivery locally without sending real emails, setting up email infrastructure in .NET Aspire, or writing integration tests that verify emails are sent.

Designing data layer architecture. Read/write split, aggregate boundaries, N+1 governance.

Testing with real infrastructure. WebApplicationFactory, Testcontainers, Aspire, fixtures.

Orienting in a .NET solution. Entry points, .sln/.slnx files, dependency graphs, config.

Multi-language support, resource files, culture formatting, and globalization patterns for ASP.NET Core Razor Pages applications. Use when implementing multi-language support in ASP.NET Core applications, managing resource files for translations, or formatting dates, numbers, and currencies for different cultures.

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.

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

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

Using Options pattern, user secrets, or feature flags. IOptions<T> and FeatureManagement.

Choosing a data access approach. EF Core vs Dapper vs ADO.NET decision matrix, performance tradeoffs.

Optimizing .NET allocations/throughput. Span, ArrayPool, ref struct, sealed, stackalloc.

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

Writing async/await code. Task patterns, ConfigureAwait, cancellation, and common agent pitfalls.

Choosing inter-service protocols. REST vs gRPC vs SignalR vs SSE decision matrix, tradeoffs.

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

Using records, pattern matching, primary constructors, collection expressions. C# 12-15 by TFM.

Choosing documentation tooling. Starlight, Docusaurus, DocFX decision tree, migration paths.

Building real-time features. SignalR hubs, SSE (.NET 10), JSON-RPC 2.0, gRPC streaming, scaling.

Production-grade patterns for ASP.NET Core Identity in Razor Pages and web apps. Covers setup, customization, security hardening, auth flows, roles/claims, external providers, and integration best practices for .NET 8+ / .NET 9+. Use when implementing authentication and authorization in ASP.NET Core applications, configuring ASP.NET Core Identity, setting up external login providers, or managing roles and claims.

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.

Creating source generators. IIncrementalGenerator, GeneratedRegex, LoggerMessage, STJ source-gen.

Registering or resolving services with MS DI. Keyed services, scopes, decoration, hosted services.

Configuration patterns using Microsoft.Extensions.Configuration. Covers configuration providers, binding, validation, and best practices for .NET applications. Use when setting up configuration in .NET applications, implementing configuration validation with IValidateOptions, or managing settings across different environments.

Enabling nullable reference types. Annotation strategies, attributes, common agent mistakes.

Dependency injection patterns and best practices using Microsoft.Extensions.DependencyInjection for .NET applications. Use when configuring DI containers in .NET, choosing between service lifetimes (Singleton, Scoped, Transient), or implementing decorator patterns and service interception.