CQRS in Practice

Name: CQRS in Practice
Price: 9 USD
Availability: InStock

4h 22m 58s

English

Paid

November 1, 2024

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.

Watch Online CQRS in Practice

Join premium to watch

Go to premium

#	Title	Duration
1	Course Overview	01:35
2	Introduction	03:30
3	CQRS and Its Origins	05:31
4	Why CQRS?	03:39
5	CQRS in the Real World	01:32
6	Summary	01:29
7	Introduction	00:20
8	Problem Domain Introduction	05:57
9	Application Code Introduction	11:31
10	Application Code Drawbacks	08:25
11	Summary	01:32
12	Introduction	00:21
13	CRUD-based Interface	07:27
14	Task-based Interface	01:49
15	Untangling the Update Method	08:31
16	Recap: Untangling the Update Method	03:26
17	Task-based User Interface	02:34
18	Dealing with Create and Delete Methods	04:35
19	Summary	03:43
20	Introduction	00:46
21	Introducing a First Command	11:31
22	Commands in CQS vs. Commands in CQRS	02:48
23	Commands and Queries in CQRS	04:41
24	Commands and Queries in the Onion Architecture	04:22
25	Commands vs. DTOs	03:59
26	Leveraging ASP.NET Core Dependency Injection to Resolve Handlers	05:18
27	Introducing a Query	06:44
28	Finishing up the Refactoring	04:41
29	Recap: Introducing Commands and Queries	03:33
30	Summary	04:28
31	Introduction	00:33
32	New Requirement: Database Retries	02:48
33	Introducing a Database Retry Decorator	08:34
34	Decorator Pattern	03:24
35	Introducing Another Decorator	02:25
36	Streamlining the Decorator Configuration	07:16
37	Recap: Streamlining the Decorator Configuration	01:29
38	Decorators vs. ASP.NET Middleware	05:27
39	Command and Query Handlers Best Practices	04:01
40	Summary	02:32
41	Introduction	00:55
42	The State of the Read Model	05:08
43	Separation of the Domain Model	05:01
44	Simplifying the Read Model	04:13
45	Recap: Simplifying the Read Model	06:40
46	The Read Model and the Onion Architecture	02:26
47	Summary	02:06
48	Introduction	00:17
49	Meet Scalability	05:02
50	Separation at the Data Level in the Real World	02:07
51	Designing a Database for Queries	03:11
52	Creating a Database for Queries	04:04
53	Recap: Creating a Database for Queries	02:00
54	Scalability	01:55
55	A Word of Caution Regarding the Database for Reads	01:58
56	Summary	02:49
57	Introduction	00:21
58	State-driven Projections	06:36
59	Synchronous State-driven Projections	03:05
60	Event-driven Projections	02:47
61	Consistency	03:41
62	Eventual Consistency	04:18
63	Versioning	01:51
64	CQRS and the CAP Theorem	03:23
65	Summary	02:16
66	Introduction	00:16
67	CQRS and Event Sourcing	02:18
68	Evolutionary Design	01:59
69	Using Commands and Queries from Handlers	03:52
70	One-way Commands	01:55
71	CQRS vs. the Specification Pattern	02:47
72	Resource List	00:59
73	Course Summary	01:55