Getting Started: Clean Architecture in .NET

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)

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 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 Overview (2:57)

Implementing Services in our Application Layer (4:44)

Clean Architecture and Dependency Injection (7:36)

Section Recap (0:34)

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)

What is the Result Pattern? (2:08)

Implementing the Result Pattern (4:09)

Section Recap (0:36)

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 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 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 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)

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)

Conclusion (0:43)