dotnet-backend-patterns

Implement .NET backend architectures with clean architecture, DI, EF Core, and Dapper patterns.

3|1|Updated Feb 3, 2026
One-click install
npx skills add https://github.com/duanbiao2000/obsidianDoc26 --skill dotnet-backend-patterns-duanbiao2000
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-backend-patterns
Source: https://github.com/duanbiao2000/obsidianDoc26/tree/main/agents-main/plugins/dotnet-contribution/skills/dotnet-backend-patterns
Command: npx skills add https://github.com/duanbiao2000/obsidianDoc26 --skill dotnet-backend-patterns-duanbiao2000

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps developers manage the complexity of building robust .NET backends by providing proven patterns, templates, and guidelines for architecture, DI, data access, configuration, caching, and testing.

Core Features & Use Cases

  • Guides clean architecture with a layered project structure (Domain, Application, Infrastructure, API).
  • Showcases dependency injection patterns, configuration with IOptions, and multiple data access patterns (EF Core, Dapper).
  • Provides testing patterns with xUnit and example unit/integration tests, plus caching and resilience best practices.

Quick Start

Study the sample project structure and begin implementing clean architecture patterns in a .NET backend.

Frequently Asked Questions about dotnet-backend-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a clean architecture .NET backend with dependency injection and EF Core?

Structure a clean architecture .NET backend using a layered project layout of Domain, Application, Infrastructure, and API. This pattern guides dependency injection, EF Core data access, and typed configuration to build robust, testable enterprise applications.

What is the best way to combine EF Core and Dapper for data access in a .NET API?

Combine EF Core and Dapper for .NET API data access by applying multiple data access patterns within a clean architecture. This approach provides sample implementations for both ORMs to optimize database operations in enterprise applications.

How does typed configuration with IOptions work in a clean architecture .NET backend?

Typed configuration with IOptions works in a .NET backend by binding strongly-typed settings classes to configuration sources. This pattern ensures robust, testable configuration management across the Application and Infrastructure layers.

Can I use xUnit for unit and integration testing in a .NET clean architecture project?

Yes, you can use xUnit for testing in a .NET clean architecture project. This approach provides testing patterns with example unit and integration tests to ensure your dependency injection and data access layers remain robust and testable.

When do I need caching and resilience patterns for .NET backend APIs?

You need caching and resilience patterns for .NET backend APIs when building robust enterprise applications that handle high traffic. These best practices optimize performance and ensure stability across your clean architecture and data access layers.