csharp-dotnet
Use when building on .NET 8+ with C# 12. Covers nullable reference types, records, async/await correctness, minimal APIs, dependency injection, and EF Core query performance. Trigger on "async deadlock in my asp.net app", "turn on nullable reference types", "ef core is doing n+1
Install
npx skills add https://github.com/nimadorostkar/Claude-Skills-collection/tree/main/skills/languages/csharp-dotnet
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install nimadorostkar-claude-skills-collection@llmmart
git clone https://github.com/nimadorostkar/Claude-Skills-collection.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole nimadorostkar/claude-skills-collection collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
C# and .NET
Purpose
Build .NET applications that are null-safe by contract, correctly asynchronous end to end, and free of the ORM traps that quietly turn one query into a thousand.
When to Use
- Writing or reviewing C# on .NET 8 or later.
- Enabling nullable reference types on an existing project.
- Designing minimal APIs or ASP.NET Core services.
- Diagnosing async deadlocks or thread-pool starvation.
- Fixing EF Core N+1 queries and tracking overhead.
Capabilities
- Nullable reference types, records, pattern matching, required members.
- Async correctness:
ConfigureAwait, cancellation tokens,IAsyncEnumerable. - Minimal APIs, endpoint filters, model validation, problem details.
- Dependency injection lifetimes and scope correctness.
- EF Core: projections, split queries, no-tracking reads, compiled queries.
Inputs
- Solution or project files and target framework.
- Whether the project is a library, web API, or worker service.
- Data-access layer and database engine.
Outputs
- Code compiling with
<Nullable>enable</Nullable>and<TreatWarningsAsErrors>true</TreatWarningsAsErrors>. - Async paths that flow a
CancellationTokenfrom request to database. - EF Core queries with explicit projection and tracking behavior.
Workflow
- Enable the gates — Nullable reference types and warnings-as-errors, project-wide.
- Model — Records for immutable values;
requiredmembers instead of constructor sprawl. - Thread cancellation — Every async method takes a
CancellationTokenand passes it down. - Shape the queries — Project to DTOs; never materialize entities you will not mutate.
- Gate — Build with warnings as errors, run analyzers, run the test suite.
Best Practices
- Never call
.Resultor.Wait()on a Task. That is how deadlocks and starvation happen — async all the way down. - Use
ConfigureAwait(false)in library code; it is unnecessary in ASP.NET Core application code. - Register
DbContextas scoped. Injecting it into a singleton is a correctness bug, not a style issue. - Read-only queries use
AsNoTracking(). Tracking every row you only intend to display wastes memory and time. - Return
Results.Problem(...)/ RFC 7807 payloads rather than bare status codes. - Validate at the endpoint, not in the domain. The domain should be able to assume its inputs are valid.
Examples
Minimal API endpoint with cancellation and projection:
app.MapGet("/orders/{id:guid}", async (
Guid id,
AppDbContext db,
CancellationToken ct) =>
{
var order = await db.Orders
.AsNoTracking()
.Where(o => o.Id == id)
.Select(o => new OrderSummary(
o.Id,
o.Customer.Name,
o.Lines.Count,
o.Lines.Sum(l => l.Price * l.Quantity)))
.SingleOrDefaultAsync(ct);
return order is null
? Results.Problem(statusCode: 404, title: "Order not found")
: Results.Ok(order);
});
Notes
IAsyncEnumerable<T>streams results without buffering the full set — use it for large exports.- EF Core's split-query mode avoids the cartesian explosion of multiple
Includes, at the cost of extra round trips. Measure both. - Source generators (e.g.
System.Text.Json) remove reflection at startup and matter a great deal for AOT and cold-start latency.
Files (claude-skills-collection)
-
SKILL.md 3.8 KB
--- name: csharp-dotnet description: Use when building on .NET 8+ with C# 12. Covers nullable reference types, records, async/await correctness, minimal APIs, dependency injection, and EF Core query performance. Trigger on "async deadlock in my asp.net app", "turn on nullable reference types", "ef core is doing n+1 queries", "set up a minimal api in .net 8". Do not use for tuning the database itself — see the database-performance skill. metadata: category: languages version: 1.0.0 tags: [csharp, dotnet, async, efcore, minimal-api] --- # C# and .NET ## Purpose Build .NET applications that are null-safe by contract, correctly asynchronous end to end, and free of the ORM traps that quietly turn one query into a thousand. ## When to Use - Writing or reviewing C# on .NET 8 or later. - Enabling nullable reference types on an existing project. - Designing minimal APIs or ASP.NET Core services. - Diagnosing async deadlocks or thread-pool starvation. - Fixing EF Core N+1 queries and tracking overhead. ## Capabilities - Nullable reference types, records, pattern matching, required members. - Async correctness: `ConfigureAwait`, cancellation tokens, `IAsyncEnumerable`. - Minimal APIs, endpoint filters, model validation, problem details. - Dependency injection lifetimes and scope correctness. - EF Core: projections, split queries, no-tracking reads, compiled queries. ## Inputs - Solution or project files and target framework. - Whether the project is a library, web API, or worker service. - Data-access layer and database engine. ## Outputs - Code compiling with `<Nullable>enable</Nullable>` and `<TreatWarningsAsErrors>true</TreatWarningsAsErrors>`. - Async paths that flow a `CancellationToken` from request to database. - EF Core queries with explicit projection and tracking behavior. ## Workflow 1. **Enable the gates** — Nullable reference types and warnings-as-errors, project-wide. 2. **Model** — Records for immutable values; `required` members instead of constructor sprawl. 3. **Thread cancellation** — Every async method takes a `CancellationToken` and passes it down. 4. **Shape the queries** — Project to DTOs; never materialize entities you will not mutate. 5. **Gate** — Build with warnings as errors, run analyzers, run the test suite. ## Best Practices - Never call `.Result` or `.Wait()` on a Task. That is how deadlocks and starvation happen — async all the way down. - Use `ConfigureAwait(false)` in library code; it is unnecessary in ASP.NET Core application code. - Register `DbContext` as scoped. Injecting it into a singleton is a correctness bug, not a style issue. - Read-only queries use `AsNoTracking()`. Tracking every row you only intend to display wastes memory and time. - Return `Results.Problem(...)` / RFC 7807 payloads rather than bare status codes. - Validate at the endpoint, not in the domain. The domain should be able to assume its inputs are valid. ## Examples **Minimal API endpoint with cancellation and projection:** ```csharp app.MapGet("/orders/{id:guid}", async ( Guid id, AppDbContext db, CancellationToken ct) => { var order = await db.Orders .AsNoTracking() .Where(o => o.Id == id) .Select(o => new OrderSummary( o.Id, o.Customer.Name, o.Lines.Count, o.Lines.Sum(l => l.Price * l.Quantity))) .SingleOrDefaultAsync(ct); return order is null ? Results.Problem(statusCode: 404, title: "Order not found") : Results.Ok(order); }); ``` ## Notes - `IAsyncEnumerable<T>` streams results without buffering the full set — use it for large exports. - EF Core's split-query mode avoids the cartesian explosion of multiple `Include`s, at the cost of extra round trips. Measure both. - Source generators (e.g. `System.Text.Json`) remove reflection at startup and matter a great deal for AOT and cold-start latency.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.