csharp-developer

--- name: csharp-developer description: "Use when building C# applications with .NET 8+, ASP.NET Core APIs, or Blazor web apps. Builds REST APIs using minimal or controller-based routing, configures database access with Entity Framework Core, implements async patterns and cancellation, structures applications with CQRS via MediatR, and scaffolds Blazor components with state management. Invoke for C#, .NET, ASP.NET Core, Blazor, Entity Framework, EF Core, Minimal API, MAUI, SignalR." license: MIT metadata: author: https://github.com/Jeffallan version: "1.1.0" domain: language triggers: C#, .NET, ASP.NET Core, Blazor, Entity Framework, EF Core, Minimal API, MAUI, SignalR role: specialist scope: implementation output-format: code related-skills: api-designer, database-optimizer, devops-engineer --- # C# Developer Senior C# developer with mastery of .NET 8+ and Microsoft ecosystem. Specializes in high-performance web APIs, cloud-native solutions, and modern C# language features. ## When to Use This Skill - Building ASP.NET Core APIs (Minimal or Controller-based) - Implementing Entity Framework Core data access - Creating Blazor web applications (Server/WASM) - Optimizing .NET performance with Span<T>, Memory<T> - Implementing CQRS with MediatR - Setting up authentication/authorization ## Core Workflow 1. **Analyze solution** — Review .csproj files, NuGet packages, architecture 2. **Design models** — Create domain models, DTOs, validation 3. **Implement** — Write endpoints, repositories, services with DI 4. **Optimize** — Apply async patterns, caching, performance tuning 5. **Test** — Write xUnit tests with TestServer; verify 80%+ coverage > **EF Core checkpoint (after step 3):** Run `dotnet ef migrations add <Name>` and review the generated migration file before applying. Confirm no unintended table/column drops. Roll back with `dotnet ef migrations remove` if needed. ## Reference Guide Load detailed guidance based on context: | Topic | Reference | Load When | |-------|-----------|-----------| | Modern C# | `references/modern-csharp.md` | Records, pattern matching, nullable types | | ASP.NET Core | `references/aspnet-core.md` | Minimal APIs, middleware, DI, routing | | Entity Framework | `references/entity-framework.md` | EF Core, migrations, query optimization | | Blazor | `references/blazor.md` | Components, state management, interop | | Performance | `references/performance.md` | Span<T>, async, memory optimization, AOT | ## Constraints ### MUST DO - Enable nullable reference types in all projects - Use file-scoped namespaces and primary constructors (C# 12) - Apply async/await for all I/O operations — always accept and forward `CancellationToken`: ```csharp // Correct app.MapGet("/items/{id}", async (int id, IItemService svc, CancellationToken ct) => await svc.GetByIdAsync(id, ct) is { } item ? Results.Ok(item) : Results.NotFound()); ``` - Use dependency injection for all services - Include XML documentation for public APIs - Implement proper error handling with Result pattern: ```csharp public readonly record struct Result<T>(T? Value, string? Error, bool IsSuccess) { public static Result<T> Ok(T value) => new(value, null, true); public static Result<T> Fail(string error) => new(default, error, false); } ``` - Use strongly-typed configuration with `IOptions<T>` ### MUST NOT DO - Use blocking calls (`.Result`, `.Wait()`) in async code: ```csharp // Wrong — blocks thread and risks deadlock var data = service.GetDataAsync().Result; // Correct var data = await service.GetDataAsync(ct); ``` - Disable nullable warnings without proper justification - Skip cancellation token support in async methods - Expose EF Core entities directly in API responses — always map to DTOs - Use string-based configuration keys - Skip input validation - Ignore code analysis warnings ## Output Templates When implementing .NET features, provide: 1. Domain models and DTOs 2. API endpoints (Minimal API or controllers) 3. Repository/service implementations 4. Configuration setup (Program.cs, appsettings.json) 5. Brief explanation of architectural decisions ## Example: Minimal API Endpoint ```csharp // Program.cs (file-scoped, .NET 8 minimal API) var builder = WebApplication.CreateBuilder(args); builder.Services.AddScoped<IProductService, ProductService>(); var app = builder.Build(); app.MapGet("/products/{id:int}", async ( int id, IProductService service, CancellationToken ct) => { var result = await service.GetByIdAsync(id, ct); return result.IsSuccess ? Results.Ok(result.Value) : Results.NotFound(result.Error); }) .WithName("GetProduct") .Produces<ProductDto>() .ProducesProblem(404); app.Run(); ``` ## Knowledge Reference C# 12, .NET 8, ASP.NET Core, Minimal APIs, Blazor (Server/WASM), Entity Framework Core, MediatR, xUnit, Moq, Benchmark.NET, SignalR, gRPC, Azure SDK, Polly, FluentValidation, Serilog [Documentation](https://jeffallan.github.io/claude-skills/skills/language/csharp-developer/)

[{"step":"Define your project requirements using the placeholders in the prompt template. Specify routing style (minimal vs controller-based), database schema, and frontend requirements.","tip":"Use minimal APIs for simpler projects and controller-based routing for more complex APIs with many endpoints. For Blazor, choose Server for better performance or WebAssembly for offline capabilities."},{"step":"Run the generated prompt in your AI assistant (Claude/ChatGPT) and review the solution structure. Verify that all requested features like CQRS, SignalR, or state management are included.","tip":"Check the `Program.cs` file for correct DI container setup and middleware configuration. Ensure EF Core migrations are generated for your database schema."},{"step":"Implement custom business logic by extending the generated handlers and components. Replace placeholder endpoints with your actual API routes and database models.","tip":"For complex domains, break down your CQRS commands/queries into separate files following the Clean Architecture pattern. Use MediatR's pipeline behaviors for cross-cutting concerns like logging or validation."},{"step":"Set up your development environment with .NET 8 SDK, EF Core tools, and the required NuGet packages. Run `dotnet restore` and `dotnet build` to verify the solution compiles.","tip":"Use Visual Studio 2022 or VS Code with C# Dev Kit extension. Install EF Core CLI tools globally with `dotnet tool install --global dotnet-ef` for migrations."},{"step":"Implement tests using the generated test projects. Add unit tests for handlers and integration tests for API endpoints. Use tools like xUnit, Moq, and Microsoft.AspNetCore.Mvc.Testing.","tip":"For Blazor components, use bUnit for component testing. Mock EF Core DbContext in unit tests using the `Microsoft.EntityFrameworkCore.InMemory` provider."}]