Claude Skill

csharp-developer

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

LLM Mart · 0 points · 2 views 0 listing impressions 0 install-command copies
Download jeffallan-claude-skills-skills_csharp-developer-190e05a.zip · 19 KB

Install

skills CLI npx skills add https://github.com/Jeffallan/claude-skills/tree/main/skills/csharp-developer
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install jeffallan-claude-skills@llmmart
Git git clone https://github.com/Jeffallan/claude-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole jeffallan/claude-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

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
  • 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

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:
    // 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:
    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:
    // 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

// 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

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Files (claude-skills)
  • references
    • aspnet-core.md 10.5 KB
      Loading…
    • blazor.md 12.6 KB
      Loading…
    • entity-framework.md 11.4 KB
      Loading…
    • modern-csharp.md 6.1 KB
      Loading…
    • performance.md 12.2 KB
      Loading…
  • SKILL.md 5.1 KB
    ---
    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
      company: https://synergetic.solutions
      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
    
    Maintained by [@jeffallan](https://github.com/jeffallan), Principal Consultant at [Synergetic Solutions](https://synergetic.solutions)
    
    [Documentation](https://jeffallan.github.io/claude-skills/skills/language/csharp-developer/)
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.