Start your .NET Clean Architecture journey
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!
Curriculum
Welcome
1:04
What will you learn in this course?
1:37
Who is the course for and prerequisites
1:49
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
Course Info
Level:
Getting Started
Duration:
3h 10m
About the Author
Amichai Mantinband
Amichai Mantinband is a Software Engineer at Microsoft and a .NET content creator.
He works on large-scale, distributed systems within Microsoft Office, serving over 100 million daily users. He is a speaker at official .NET conferences, and within Microsoft, he authors and teaches software architecture courses.
Amichai is the author of NuGet packages ErrorOr & Throw and has a .NET programming YouTube channel covering advanced topics such as design patterns, architecture, and best practices.
© 2023 Dometrain. All rights reserved.