Pragmatic Clean Architecture

6h 21m 27s
English
Paid

Course description

This comprehensive course will teach you the system I use to ship production-ready applications using Clean Architecture. Learn how to apply the best practices of modern software architecture. Join 2,600+ other students to accelerate your growth as a software architect.

Read more about the course

Clean Architecture Deep-Dive

  1. Learn the architectural principles to make better decisions
  2. How to design applications that stand the test of time
  3. Where should you use Clean Architecture


Build a Rich Domain Layer with DDD

  1. A practical guide to using Domain-Driven Design
  2. Learn the most important DDD tactical patterns
  3. Best practices for designing a rich domain model


Clean Application Layer use cases

  1. Learn how to implement clean use cases with CQRS
  2. Solve cros-cutting concerns with ease
  3. How to achieve blazing query speed


Powerful Infrastructure Layer

  1. How to implement a blazing fast persistence layer
  2. Get the most from advanced EF Core features
  3. Learn how to solve concurrency issues


Elegant Presentation Layer

  1. How to set up dependency injection the right way
  2. Configuration management and documentation
  3. Adding API and endpoints efficiently


Bulletproof Authentication

  1. Implement robust JWT authentication to secure your API
  2. Learn how to integrate an external identity provider
  3. How to apply modern security best practices


Robust Authorization NEW

  1. Learn how to implement custom authorization policies
  2. Role-based and permission-based authorization
  3. Why you need resource-based authorization


Production-Ready Advanced Features NEW

  1. Structured logging, health checks, API versioning
  2. Improve scalability with background jobs
  3. Distributed caching with Redis


High-Quality Testing NEW

  1. Learn how to test complex systems the right way
  2. Unit testing, Integration testing, Functional (E2E) testing
  3. Enforce your software architecture with architecture tests


After Completing This Course You Will

  1. Confidently use Clean Architecture to build amazing projects at your work
  2. Build a rich domain model with Domain-Driven Design fundamentals
  3. Set up production-ready applications with industry best practices
  4. Understand the most important architectural principles

Watch Online

Join premium to watch
Go to premium
# Title Duration
1 Welcome 00:44
2 What you will learn in this course 01:03
3 Who this course is for 00:55
4 What are the prerequisites for taking this course 01:07
5 Architectural principles & Design principles 06:12
6 Clean Architecture layers 03:07
7 What we are building & why 01:49
8 Chapter recap 00:36
9 Introduction 02:01
10 Creating the Domain project 01:05
11 Defining our first domain entity 04:03
12 What is an Entity in Domain-Driven Design? 02:39
13 Introducing Value Objects for solving primitive obsession 08:24
14 The importance of private setters in the domain model and encapsulation 00:25
15 Using the Static Factory pattern in the domain 03:12
16 Introducing the Domain Events pattern to the solution 03:09
17 Adding Repositories and the Unit of Work to the domain 01:54
18 Creating the Booking entity 03:32
19 Implementing a Domain service 03:58
20 Using Double Dispatch for a better domain model 01:21
21 Introducing the Result class to the project 03:17
22 Defining a dictionary of domain errors 01:19
23 Chapter recap 00:27
24 Introduction 05:09
25 Creating the Application project 00:24
26 Configuring dependency injection and installing MediatR 02:32
27 Adding the required abstractions for CQRS 03:40
28 Implementing Commands with the rich domain model & repositories 08:47
29 Defining a domain event handler 04:26
30 Implementing Queries with Dapper for blazing performance 09:50
31 Solving logging as a cross-cutting concern 03:49
32 Creating a Validation pipeline for commands 05:47
33 Chapter recap 00:38
34 Introduction 01:02
35 Creating the Infrastructure project 00:22
36 Configuring infrastructure services with dependency injection 03:07
37 Adding Entity Framework Core to the solution 01:25
38 Configuring Entity Framework Core with dependency injection 01:38
39 Creating the Domain entity configurations 03:35
40 Automatically applying entity configurations 00:46
41 Implementing repository interfaces using a generic repository 03:00
42 Implementing the SQL connection factory 01:52
43 Publishing domain events inside the Unit of Work 04:18
44 Solving race conditions with optimistic concurrency 04:42
45 Chapter recap 00:28
46 Introduction 01:06
47 Creating the Presentation project 02:40
48 Configuring services with dependency injection 00:53
49 Adding Controllers and endpoints 05:34
50 Setting up Docker Compose and running the API 03:49
51 Creating EF migrations and applying them 04:20
52 Seeding initial data 01:45
53 Adding Middleware - Global exception handler 02:30
54 Demo: Presentation layer & API 01:59
55 Chapter recap 00:38
56 Introduction 01:20
57 Keycloak identity provider setup 02:07
58 Keycloak admin panel overview 01:23
59 Demo: Obtaining JWTs using Keycloak 01:40
60 Configuring authentication middleware & services 01:58
61 Configuring JWT authentication options 02:09
62 Demo: Authentication in action 00:43
63 Implementing the user registration feature 02:57
64 Adding an API endpoint for registering a user 01:22
65 Implementing the authentication service 03:02
66 Configuring the authentication service as a typed HTTP client 01:50
67 Demo: User registration with Keycloak 00:48
68 Implementing the user login feature 03:06
69 Demo: User login with Keycloak 00:44
70 Chapter recap 00:24
71 Introduction 00:38
72 Implementing Role-based Authorization 17:47
73 Implementing Permission-based Authorization 15:15
74 Implementing Resource-based Authorization 06:18
75 Chapter recap 00:32
76 Introduction 00:38
77 Structured Logging with Serilog and Seq 17:24
78 Distributed Caching with Redis 16:34
79 Health Checks in Clean Architecture 08:37
80 Implementing API Versioning 12:03
81 Transactional Outbox Pattern 20:23
82 Minimal APIs 09:49
83 Chapter recap 00:37
84 Introduction 01:03
85 Domain Layer Unit Testing 15:37
86 Application Layer Unit Testing 16:45
87 Integration Testing 18:46
88 Functional Testing 13:22
89 Architecture Testing 08:40
90 Chapter recap 00:46
91 One Small Ask From Me 01:30

Books

Read Book Pragmatic Clean Architecture

#Title
1Pragmatic Clean Architecture

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Blazor From Start to Finish

Blazor From Start to Finish

Sources: iamtimcorey.com (Tim Corey)
Blazor is a game changer for developers. But figuring out how to access the full power of Blazor can leave you frustrated. Can it really replace Javascript completely? What is ...
14 hours 19 minutes 46 seconds
Entity Framework Core - The Complete Guide (.NET Core 5)

Entity Framework Core - The Complete Guide (.NET Core 5)

Sources: udemy
Entity Framework is a term that goes hand by hand with ASP.NET Core. It is one of that technology that is used very often and is not understood most of the time. This course wil...
5 hours 24 minutes 16 seconds
.NET/ C# Interview Masterclass - Top 500 Questions & Answers

.NET/ C# Interview Masterclass - Top 500 Questions & Answers

Sources: udemy
Are you checking out multiple websites and videos for collecting the interview questions? Your search is over here. All .NET interview questions are covered in this question ban...
8 hours 31 minutes 35 seconds