dotnet-tactical-ddd

Apply tactical Domain-Driven Design patterns to .NET backends with EF Core.

Updated Jan 15, 2026
One-click install
npx skills add https://github.com/fiatkongen/saurun-marketplace --skill dotnet-tactical-ddd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-tactical-ddd
Source: https://github.com/fiatkongen/saurun-marketplace/tree/main/plugins/saurun/skills/dotnet-tactical-ddd
Command: npx skills add https://github.com/fiatkongen/saurun-marketplace --skill dotnet-tactical-ddd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps .NET teams apply tactical Domain-Driven Design to build domain-centric backends with clear boundaries between Domain, Application, and Infrastructure, reducing anemic entities and controller-driven logic.

Core Features & Use Cases

  • Value Objects, Entities, and Aggregates to encode business rules and invariants.
  • Domain Events and domain services to coordinate multiple aggregates without leaking internals.
  • DTO boundaries and explicit mappings to keep APIs decoupled from domain models.

Quick Start

Copy the base-domain scaffolding into your Domain project, create private-property entities with factory methods, and implement mappings to API DTOs. Then configure EF Core to map owned types and private collections as described in the guidelines.

Frequently Asked Questions about dotnet-tactical-ddd

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

FAQPage Schema
How do I implement tactical Domain-Driven Design in a .NET backend?

Implement tactical Domain-Driven Design in .NET by structuring your backend into Domain, Application, and Infrastructure layers. Use Value Objects, Entities, and Aggregates to encode business rules, and apply repository patterns to maintain clear boundaries.

How do I map private fields and owned types using EF Core in DDD?

Map private fields and owned types in EF Core by applying explicit configuration within your Infrastructure layer. This ensures persistence mapping remains decoupled from your domain models, allowing private property entities to enforce invariants without exposing setters.

What is the best way to decouple API DTOs from domain models in C#?

The best way to decouple API DTOs from domain models in C# is by enforcing DTO boundaries and explicit mappings. This prevents leaking internal domain structures to your API consumers and keeps controllers decoupled from core business logic.

When do I need Aggregates and Domain Events in C#?

You need Aggregates and Domain Events in C# when coordinating multiple aggregates with complex business rules and invariants. Domain Events allow domain services to coordinate cross-aggregate logic without leaking internal entity details to other layers.

Can I eliminate anemic entities and controller-driven logic using DDD in .NET?

You can eliminate anemic entities and controller-driven logic in .NET by adopting a domain-centric architecture. Moving business rules into Value Objects, Entities, and Aggregates reduces passive data models and centralizes logic in the Domain layer.

Does tactical DDD require separate Domain and Application projects in .NET?

Tactical DDD requires separate Domain and Application projects in .NET to establish clear boundaries. Separating these layers ensures domain invariants stay isolated from infrastructure concerns and application orchestration workflows.