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

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 91 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing

Watch Online Pragmatic Clean Architecture

0:00
/
#1: Welcome

All Course Lessons (91)

#Lesson TitleDurationAccess
1
Welcome Demo
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

Unlock unlimited learning

Get instant access to all 90 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Pragmatic Clean Architecture

#Title
1Pragmatic Clean Architecture

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

C# Mastercourse

C# Mastercourse

Sources: iamtimcorey.com (Tim Corey)
C# is the coding language used to build applications across the web, mobile, desktop, and games. The world runs on applications. When you learn C#, you learn a skill the world ...
70 hours 40 minutes 18 seconds
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