English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 64 Lessons (3h 11m) | 738 MB
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!
Table of Contents
1 Welcome
2 What will you learn in this course
3 Who is the course for and prerequisites
4 What is Software Architecture
5 What are Architectural Patterns
6 Layered Architecture
7 Domain-Centric Architecture
8 What is Clean Architecture
9 Section Recap
10 The Domain We’ll Explore in this Course
11 The Project We Will Build & How this Course is Built
12 Project Setup Following Clean Architecture
13 Sending Requests Using .http Files
14 Section Recap – Dometrain by Nick Chapsas
15 Presentation Layer Overview
16 Implementing Presentation Layer Contracts
17 Implementing Controllers in the Presentation Layer
18 Presentation Layer Frameworks in .NET
19 Section Recap
20 Application Layer Overview
21 Implementing Services in our Application Layer
22 Clean Architecture and Dependency Injection
23 Section Recap
24 What is the CQRS Pattern
25 Implementing the CQRS Pattern
26 What is the Mediator Pattern
27 Implementing the Mediator Pattern Using the MediatR NuGet Package
28 Splitting by Feature vs. Splitting by Type
29 Section Recap
30 What is the Result Pattern
31 Implementing the Result Pattern
32 Section Recap
33 What is the Repository Pattern
34 Implementing the Repository Pattern in the Application Layer
35 What is the Unit of Work Pattern
36 Implementing the Unit of Work pattern in the Application Layer
37 Section Recap
38 Infrastructure Layer Overview
39 Implementing the Repository Pattern in the Infrastructure Layer
40 Implementing the Repository Pattern Using EF Core in the Infrastructure Layer
41 Implementing the Unit of Work Pattern in the Infrastructure Layer
42 EF Core and the Repository Pattern
43 Section Recap
44 Domain-Driven Design vs. Clean Architecture
45 What is Domain-Driven Design
46 Domain Models
47 Rich vs. Anemic Domain Models
48 Always Valid Domain Models
49 Persistence Ignorance
50 Section Recap
51 Domain Layer Overview
52 Implementing Strongly Typed Enums
53 Implementing Domain Models
54 Implementing Domain Model EF Core Configurations
55 Final Project Overview
56 Final Project Code Walkthrough
57 Section Recap
58 Domain Layer Errors vs. Application Layer Errors vs. Presentation Layer Errors
59 Error Handling Approaches in Clean Architecture
60 Implementing Domain Layer Errors
61 Implementing Application Layer Errors
62 Converting Domain and Application Layer Errors to Presentation Errors
63 Section Recap
64 Conclusion
Resolve the captcha to access the links!