Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Getting Started: Clean Architecture in .NET
Course overview
Welcome (1:04)
What will you learn in this course? (1:37)
Who is the course for and prerequisites (1:49)
Introduction to Clean Architecture
What is Software Architecture? (1:42)
What are Architectural Patterns? (1:01)
Layered Architecture (4:42)
Domain-Centric Architecture (1:35)
What is Clean Architecture? (3:28)
Section Recap (1:14)
Project Setup and Utilities
The Domain We'll Explore in this Course (4:29)
The Project We Will Build & How this Course is Built (2:22)
Project Setup Following Clean Architecture (3:09)
Sending Requests Using .http Files (2:01)
Section Recap (0:43)
Presentation Layer
Presentation Layer Overview (2:50)
Implementing Presentation Layer Contracts (5:15)
Implementing Controllers in the Presentation Layer (1:50)
Presentation Layer Frameworks in .NET (1:09)
Section Recap (0:53)
Application Layer
Application Layer Overview (2:57)
Implementing Services in our Application Layer (4:44)
Clean Architecture and Dependency Injection (7:36)
Section Recap (0:34)
CQRS & Mediator Patterns
What is the CQRS Pattern? (3:48)
Implementing the CQRS Pattern (0:31)
What is the Mediator Pattern? (1:41)
Implementing the Mediator Pattern Using the MediatR NuGet Package (7:47)
Splitting by Feature vs. Splitting by Type (2:43)
Section Recap (0:54)
Result Pattern
What is the Result Pattern? (2:08)
Implementing the Result Pattern (4:09)
Section Recap (0:36)
Repository & Unit of Work Patterns
What is the Repository Pattern? (3:52)
Implementing the Repository Pattern in the Application Layer (3:46)
What is the Unit of Work Pattern? (2:13)
Implementing the Unit of Work pattern in the Application Layer (1:56)
Section Recap (0:46)
Infrastructure Layer
Infrastructure Layer Overview (1:32)
Implementing the Repository Pattern in the Infrastructure Layer (4:45)
Implementing the Repository Pattern Using EF Core in the Infrastructure Layer (5:52)
Implementing the Unit of Work Pattern in the Infrastructure Layer (2:31)
EF Core and the Repository Pattern (3:47)
Section Recap (0:38)
Domain-Driven Design 1000 ft. View
Domain-Driven Design vs. Clean Architecture (1:50)
What is Domain-Driven Design? (2:15)
Domain Models (0:38)
Rich vs. Anemic Domain Models (3:23)
Always Valid Domain Models (1:49)
Persistence Ignorance (1:34)
Section Recap (1:40)
Domain Layer
Domain Layer Overview (3:18)
Implementing Strongly Typed Enums (2:11)
Implementing Domain Models (5:58)
Implementing Domain Model EF Core Configurations (5:55)
Final Project Overview (2:15)
Final Project Code Walkthrough (5:07)
Section Recap (1:10)
Bonus: Error Handling in Clean Architecture
Domain Layer Errors vs. Application Layer Errors vs. Presentation Layer Errors (9:07)
Error Handling Approaches in Clean Architecture (6:17)
Implementing Domain Layer Errors (4:22)
Implementing Application Layer Errors (3:01)
Converting Domain and Application Layer Errors to Presentation Errors (10:54)
Section Recap (1:49)
Course conclusion
Conclusion (0:43)
Rate this course
What will you learn in this course?
Complete and Continue