Welcome
What will you learn in this course?
Who is the course for and prerequisites
Getting Started: Clean Architecture in .NET
Learn the principles of Clean Architecture in .NET with real-world examples. This course teaches you to build scalable, maintainable systems using proven architectural patterns.
About This Course
Clean Architecture is one of the most popular software architecture and solution
organization approaches out there, and that's for a good reason. It provides a
clear path to a robust solution structure with clear guidelines and rules that
help you fall into the pit of success immediately. It can, however, be confusing
and complicated at first, especially if you don't have an experienced developer
explaining the concept and principles to you. That's where Dometrain comes in.
In this course, Amichai Mantinband, a Software Engineer at Microsoft, will help
you start with Clean Architecture and teach you all the principles and rules in
easy-to-digest clips and understandable examples. Start your Clean Architecture
journey today on Dometrain!
Course Curriculum
3h 10m 13 sections
What is Software Architecture?
What are Architectural Patterns?
Layered Architecture
Domain-Centric Architecture
What is Clean Architecture?
Section Recap
The Domain We'll Explore in this Course
The Project We Will Build & How this Course is Built
Project Setup Following Clean Architecture
Sending Requests Using .http Files
Section Recap
Presentation Layer Overview
Implementing Presentation Layer Contracts
Implementing Controllers in the Presentation Layer
Presentation Layer Frameworks in .NET
Section Recap
Application Layer Overview
Implementing Services in our Application Layer
Clean Architecture and Dependency Injection
Section Recap
What is the CQRS Pattern?
Implementing the CQRS Pattern
What is the Mediator Pattern?
Implementing the Mediator Pattern Using the MediatR NuGet Package
Splitting by Feature vs. Splitting by Type
Section Recap
What is the Result Pattern?
Implementing the Result Pattern
Section Recap
What is the Repository Pattern?
Implementing the Repository Pattern in the Application Layer
What is the Unit of Work Pattern?
Implementing the Unit of Work pattern in the Application Layer
Section Recap
Infrastructure Layer Overview
Implementing the Repository Pattern in the Infrastructure Layer
Implementing the Repository Pattern Using EF Core in the Infrastructure Layer
Implementing the Unit of Work Pattern in the Infrastructure Layer
EF Core and the Repository Pattern
Section Recap
Domain-Driven Design vs. Clean Architecture
What is Domain-Driven Design?
Domain Models
Rich vs. Anemic Domain Models
Always Valid Domain Models
Persistence Ignorance
Section Recap
Domain Layer Overview
Implementing Strongly Typed Enums
Implementing Domain Models
Implementing Domain Model EF Core Configurations
Final Project Overview
Final Project Code Walkthrough
Section Recap
Domain Layer Errors vs. Application Layer Errors vs. Presentation Layer Errors
Error Handling Approaches in Clean Architecture
Implementing Domain Layer Errors
Implementing Application Layer Errors
Converting Domain and Application Layer Errors to Presentation Errors
Section Recap
Conclusion
Meet Your Instructor
Amichai Mantinband
© 2026 Dometrain. All rights reserved.
