# Build Production-Ready .NET Backends

Complex .NET backends need consistent architecture, data access, resilience, and testing patterns. This skill supplies focused guidance and reusable C# templates for those decisions.

## Install

```bash
npx skillstore add sickn33/dotnet-backend-patterns
```

## Metadata

- Status: approved
- Slug: sickn33-dotnet-backend-patterns
- Skillstore revision: r2
- Version status: missing
- Tree hash: c25ad5c30826ad01ae81d6e01f1e6e27e527da530be4af3574f4126b08d8e983
- Author: sickn33
- GitHub username: sickn33
- License: MIT
- Repository: https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/dotnet-backend-patterns
- Ref: 88a8e9a07f4c54ab105c1c41b6267c287146b07b
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: external\_commands, filesystem
- Quality score: 78
- Quality tier: bronze
- Public page: https://skillstore.pages.dev/skills/sickn33-dotnet-backend-patterns
- Manifest: https://skillstore.pages.dev/api/skills/sickn33-dotnet-backend-patterns/manifest

## Capabilities

- Defines Clean Architecture boundaries, modules, service layers, repositories, and dependency injection lifetimes.
- Applies async and await, cancellation tokens, typed configuration, result types, and resilience patterns.
- Reviews EF Core queries, tracking, batching, transactions, indexes, concurrency, and connection pooling.
- Shows parameterized Dapper queries, mappings, transactions, type handlers, cancellation, and repository patterns.
- Designs multi-level caching with memory and Redis, including invalidation and stampede controls.
- Creates unit and integration testing approaches with xUnit, Moq, and WebApplicationFactory.

## Use Cases

- Plan a New API: Create architecture boundaries, dependency registrations, data access choices, caching, error handling, and tests for a new .NET API.
- Review Data Access: Assess EF Core and Dapper code for query efficiency, parameterization, tracking, transactions, indexing, and cancellation support.
- Modernize a Service: Replace blocking calls, weak configuration, fragile caching, and missing tests with current .NET backend patterns.

## Prompt Templates

### Explain a Backend Pattern

```
Explain the [pattern] for a developer new to .NET. Include its purpose, appropriate use cases, tradeoffs, and a short implementation outline.
```

### Design an API Feature

```
Design a .NET implementation for [feature]. Cover architecture boundaries, dependency injection, async behavior, validation, data access, errors, caching, and tests.
```

### Review Repository Code

```
Review the provided EF Core or Dapper repository. Identify correctness, performance, security, cancellation, transaction, and maintainability issues. Prioritize findings and suggest focused changes.
```

### Plan a Backend Modernization

```
Create a phased modernization plan for this .NET backend and its constraints. Compare architecture options and identify migration risks. Include tests, observability, rollout, and rollback.
```

## Limitations

- The skill needs project code and requirements before it can provide a specific review or implementation.
- Templates require adaptation for the selected .NET version, database provider, deployment environment, and domain model.
- The guidance does not replace security review, load testing, migration planning, or production monitoring.
- The resources do not provide detailed MCP protocol, transport, authentication, or tool registration examples.

## Best Practices

- Provide the target .NET version, database provider, deployment model, performance goals, and relevant code.
- Ask for prioritized findings with explicit correctness, security, performance, and maintainability impacts.
- Validate suggested patterns with project tests, query plans, benchmarks, and production-like integration environments.

## Anti Patterns

- Do not apply repository, caching, or resilience patterns without a concrete requirement and measured benefit.
- Do not copy templates without adapting ownership, transactions, validation, authorization, and failure handling.
- Do not treat example configuration values or provider-specific APIs as production defaults.

## Security Audit

- Audited at: 2026-07-23T22:59:27.924\+00:00
- Summary: All 32 static findings are false positives caused by ordinary C\# identifiers, Markdown code spans, and the term .NET. The reviewed content provides documentation and templates, with no command execution, hidden-file access, system reconnaissance, prompt injection, or malicious intent.

## Stats

- Views: 135
- Downloads: 14
- Favorites: 0
- Popularity score: 0