Getting Started: Clean Architecture in .NET

3h 10m 59s
English
Paid
January 9, 2024

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!

Watch Online Getting Started: Clean Architecture in .NET

Join premium to watch
Go to premium
# Title Duration
1 Welcome 01:05
2 What will you learn in this course? 01:38
3 Who is the course for and prerequisites 01:50
4 What is Software Architecture? 01:43
5 What are Architectural Patterns? 01:02
6 Layered Architecture 04:43
7 Domain-Centric Architecture 01:36
8 What is Clean Architecture? 03:29
9 Section Recap 01:15
10 The Domain We'll Explore in this Course 04:30
11 The Project We Will Build & How this Course is Built 02:23
12 Project Setup Following Clean Architecture 03:10
13 Sending Requests Using .http Files 02:02
14 Section Recap 00:44
15 Presentation Layer Overview 02:51
16 Implementing Presentation Layer Contracts 05:16
17 Implementing Controllers in the Presentation Layer 01:51
18 Presentation Layer Frameworks in .NET 01:10
19 Section Recap 00:54
20 Application Layer Overview 02:58
21 Implementing Services in our Application Layer 04:45
22 Clean Architecture and Dependency Injection 07:37
23 Section Recap 00:35
24 What is the CQRS Pattern? 03:49
25 Implementing the CQRS Pattern 00:32
26 What is the Mediator Pattern? 01:42
27 Implementing the Mediator Pattern Using the MediatR NuGet Package 07:48
28 Splitting by Feature vs. Splitting by Type 02:44
29 Section Recap 00:55
30 What is the Result Pattern? 02:09
31 Implementing the Result Pattern 04:10
32 Section Recap 00:37
33 What is the Repository Pattern? 03:53
34 Implementing the Repository Pattern in the Application Layer 03:47
35 What is the Unit of Work Pattern? 02:14
36 Implementing the Unit of Work pattern in the Application Layer 01:57
37 Section Recap 00:47
38 Infrastructure Layer Overview 01:33
39 Implementing the Repository Pattern in the Infrastructure Layer 04:46
40 Implementing the Repository Pattern Using EF Core in the Infrastructure Layer 05:53
41 Implementing the Unit of Work Pattern in the Infrastructure Layer 02:32
42 EF Core and the Repository Pattern 03:48
43 Section Recap 00:39
44 Domain-Driven Design vs. Clean Architecture 01:51
45 What is Domain-Driven Design? 02:16
46 Domain Models 00:39
47 Rich vs. Anemic Domain Models 03:24
48 Always Valid Domain Models 01:50
49 Persistence Ignorance 01:35
50 Section Recap 01:41
51 Domain Layer Overview 03:19
52 Implementing Strongly Typed Enums 02:12
53 Implementing Domain Models 05:59
54 Implementing Domain Model EF Core Configurations 05:56
55 Final Project Overview 02:16
56 Final Project Code Walkthrough 05:08
57 Section Recap 01:11
58 Domain Layer Errors vs. Application Layer Errors vs. Presentation Layer Errors 09:08
59 Error Handling Approaches in Clean Architecture 06:18
60 Implementing Domain Layer Errors 04:23
61 Implementing Application Layer Errors 03:02
62 Converting Domain and Application Layer Errors to Presentation Errors 10:55
63 Section Recap 01:50
64 Conclusion 00:44

Similar courses to Getting Started: Clean Architecture in .NET

From Zero to Hero: Minimal APIs in .NET with C#

From Zero to Hero: Minimal APIs in .NET with C#

Duration 3 hours 33 minutes 6 seconds
Fullstack ASP.NET Core and React Masterclass | Learnify

Fullstack ASP.NET Core and React Masterclass | Learnify

Duration 20 hours 40 minutes 31 seconds
From Zero to Hero: From Microservices to Modular Monoliths

From Zero to Hero: From Microservices to Modular Monoliths

Duration 2 hours 26 minutes 23 seconds
Unity RPG Shops & Abilities: Intermediate C# Game Coding

Unity RPG Shops & Abilities: Intermediate C# Game Coding

Duration 18 hours 51 minutes 42 seconds
Unity Android : Build 8 Mobile Games with Unity & C#

Unity Android : Build 8 Mobile Games with Unity & C#

Duration 16 hours 50 minutes 56 seconds
From Zero to Hero: Dependency Injection in .NET

From Zero to Hero: Dependency Injection in .NET

Duration 4 hours 41 minutes 41 seconds
Deep Dive: Clean Architecture in .NET

Deep Dive: Clean Architecture in .NET

Duration 3 hours 51 minutes 32 seconds
Blazor From Start to Finish

Blazor From Start to Finish

Duration 14 hours 19 minutes 46 seconds
Getting Started: Modular Monoliths in .NET

Getting Started: Modular Monoliths in .NET

Duration 3 hours 11 minutes 11 seconds
From Zero to Hero: Integration testing in ASP.NET Core

From Zero to Hero: Integration testing in ASP.NET Core

Duration 4 hours 15 minutes 47 seconds