English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 4h 22m | 749 MB
There are a lot of misconceptions around the CQRS pattern. This course is an in-depth guideline into every concern or implementation question you’ve ever had about CQRS.
There are a lot of misconceptions around the CQRS pattern, especially when it comes to applying it in real-world software projects. In this course, CQRS in Practice, you will learn all about CQRS with event sourcing, database configuration for reads and writes, and more. First, you will learn exactly what CQRS is, the principles behind it, and the benefits it can provide for your project. Next, you will explore the common misconceptions and anti-patterns around CQRS. Finally, you will see a detailed, step-by-step implementation of this pattern in practice. The sample project you’ll be working on is close to what you will find in the real world, and you will see each step on the way to CQRS in great detail. By the end of this course, you will have a foundational understanding of the CQRS pattern and how to implement it in your software projects.
Table of Contents
Course Overview
1 Course Overview
Introduction
2 Introduction
3 CQRS and Its Origins
4 Why CQRS
5 CQRS in the Real World
6 Summary
Introducing a Sample Project
7 Introduction
8 Problem Domain Introduction
9 Application Code Introduction
10 Application Code Drawbacks
11 Summary
Refactoring Towards a Task-based Interface
12 Introduction
13 CRUD-based Interface
14 Task-based Interface
15 Untangling the Update Method
16 Recap – Untangling the Update Method
17 Task-based User Interface
18 Dealing with Create and Delete Methods
19 Summary
Segregating Commands and Queries
20 Introduction
21 Introducing a First Command
22 Commands in CQS vs. Commands in CQRS
23 Commands and Queries in CQRS
24 Commands and Queries in the Onion Architecture
25 Commands vs. DTOs
26 Leveraging ASP.NET Core Dependency Injection to Resolve Handlers
27 Introducing a Query
28 Finishing Up the Refactoring
29 Recap – Introducing Commands and Queries
30 Summary
Implementing Decorators upon Command and Query Handlers
31 Introduction
32 New Requirement – Database Retries
33 Introducing a Database Retry Decorator
34 Decorator Pattern
35 Introducing Another Decorator
36 Streamlining the Decorator Configuration
37 Recap – Streamlining the Decorator Configuration
38 Decorators vs. ASP.NET Middleware
39 Command and Query Handlers Best Practices
40 Summary
Simplifying the Read Model
41 Introduction
42 The State of the Read Model
43 Separation of the Domain Model
44 Simplifying the Read Model
45 Recap – Simplifying the Read Model
46 The Read Model and the Onion Architecture
47 Summary
Introducing a Separate Database for Queries
48 Introduction
49 Meet Scalability
50 Separation at the Data Level in the Real World
51 Designing a Database for Queries
52 Creating a Database for Queries
53 Recap – Creating a Database for Queries
54 Scalability
55 A Word of Caution Regarding the Database for Reads
56 Summary
Synchronizing the Commands and Queries Databases
57 Introduction
58 State-driven Projections
59 Synchronous State-driven Projections
60 Event-driven Projections
61 Consistency
62 Eventual Consistency
63 Versioning
64 CQRS and the CAP Theorem
65 Summary
CQRS Best Practices and Misconceptions
66 Introduction
67 CQRS and Event Sourcing
68 Evolutionary Design
69 Using Commands and Queries from Handlers
70 One-way Commands
71 CQRS vs. the Specification Pattern
72 Resource List
73 Course Summary
Resolve the captcha to access the links!