Asynchronous messaging is a must for any application, whether monolithic or part of a microservices architecture. Messaging allows applications to offload work so it can be done later while providing the best customer experience for the user. It also allows us to load-level our systems and prevent spikes in traffic from taking down our system. Queues, as well as Topics with a Pub/Sub model, are a staple of any good system and a required skill for any company. In this course, Irina Scurtu will assume zero messaging knowledge, and she will teach you everything you need to know to understand asynchronous messaging in .NET and explain how you can simplify the process of integrating it into your applications by using the very popular library, MassTransit.
Welcome (01:59)
What will you learn in this course? (03:04)
Who is the course for and prerequisites (02:05)
Communication between services (03:15)
What is the Problem with HTTP APIs? (06:23)
RPC vs Messaging (06:14)
Why asynchronous messaging? (06:23)
Things to consider when using asynchronous messaging (03:23)
Fallacies of distributed computing (13:35)
Types of coupling (06:14)
Elements of a messaging system (01:26)
Channels (01:36)
Pipes & Filters (01:01)
Understanding messages (02:27)
Types of messages (00:37)
Events (03:21)
Commands (01:21)
Commands vs Events (01:39)
Producers (01:03)
Consumers/Receivers (02:09)
Pull & Push consumption models (01:59)
Queues (01:47)
Topics & Subscriptions (01:28)
Message brokers/Buses (05:49)
Brokers vs brokerless (03:41)
Dead-lettering & poison messages (01:22)
Load leveling (01:51)
Delivery modes/guarantees (02:38)
Transports (03:37)
Event-Driven (01:50)
Event-sourcing (02:59)
Section complete (00:34)
Installing RabbitMQ (02:28)
RabbitMQ concepts (02:01)
Exchange types (03:34)
MassTransit overview (01:22)
Advantages of using MassTransit (02:51)
Installing MassTransit templates (03:14)
Demo: Opening & preparing the solution (01:33)
Bus configuration (09:28)
Message contracts (03:00)
Sending a message (12:06)
Messages in detail (08:54)
Consuming a message (04:55)
Registering & tuning a message consumer (12:32)
Configuring consumers & handling errors (09:35)
Endpoints - configuring (08:17)
Topologies (05:56)
Changing the Exchange types (11:15)
The middleware concept (03:24)
Pipes & filters (03:40)
Implementing different filter types (29:46)
Configure retries (10:02)
Using Exception Filters & Delayed redeliveries (07:26)
Using CircuitBreakers (02:54)
Point to point (01:06)
Fire & Forget (01:16)
Publish/Subscribe (06:53)
Request/Reply (26:13)
Competing consumers (04:39)
Introduction (04:56)
Getting familiar with the Outbox project (01:40)
Implementing the outbox pattern (18:03)
What is the Saga pattern (10:44)
What is a State machine (02:51)
Implementing a state machine (14:03)
Registering & Running the Saga in memory (12:24)
Running the Saga and persisting it (08:26)
Testing in MassTransit (03:26)
Looking at tests (02:19)
Course conclusion (02:18)
Course Info
Irina Scurtu (Dominte) is a software architect, international speaker, Microsoft MVP for developer technologies, and Microsoft certified trainer (MCT) with a wealth of experience. Having taught classes, workshops, and presentations for over 2,000 hours, Irina is passionate about coding and keeping abreast of the latest trends and best practices in software architecture and .NET. Twice a year, for five months each time, Irina teaches .NET and C# to aspiring software developers or people interested in software development or seeking to expand their knowledge. She is an active member of the community and has founded the DotNet Iasi User Group and the dotnetdays.ro conference, where she connects with like-minded developers who are eager to share their expertise and insights. Irina is also a prolific blogger, and her website, https://irina.codes, features a wealth of articles on various coding topics.
More courses by Irina Scurtu© 2023 Dometrain. All rights reserved.