Akka.NET makes building concurrent, scalable, reactive, self-healing, and distributed systems easier. Even though Akka.NET actors help us to manage concurrency, they only process one message at a time. This may lead to bottlenecks, reduced message throughput and reduced system responsiveness. By the end of this course you'll know how to increase and optimize the throughput of messages through actors and create more performant, reactive, and scalable systems.
Regulating Message Processing with Stashing Hi, welcome back. In this module we're going to see how we can regulate the processing of messages by using message stashing in Akka. NET. One powerful feature of Akka. NET is its ability to decide if we want to handle a message now, or save it for processing in the future. This gives us the ability to create powerful workflows with very little code. So in this module we're going to start off by getting a high-level overview of what message stashing is and also some example use cases of where this powerful technique can come in handy. We'll then dig in to the Akaa. NET stashing API, and we'll learn the three primary methods that we can use to work with this API. We'll then get an overview of the modified demo application from the previous module, and we're going to see how in this modified version if we're sending high-value payments during peak hours, these payments take longer to process. We'll learn how we can use message stashing in this example to regulate the processing and throughput of messages, which don't take as long to process during peak times. Once we've added this message stash we'll also go and periodically un-stash messages, so we can process longer running messages outside of peak hours.
Increasing Asynchronous Message Throughput Hi, welcome back. In this module we're going to see how we can increase the throughput of messages when we're working with asynchronous code. So in this module we're going to start off by looking at some of the effects executing blocking code in actors can have on our message throughput. So we'll see one of the effects of this is that it's actually going to slow down the message throughputs in our actors. In the worst case scenario, we'll also see how we can deadlock our actor so it will no longer process any more messages. We'll learn how we can use async and await in our actor code to improve message throughput. And finally, we'll see how we can use the Akka. NET PipeTo pattern as an alternative to using async/await to more accurately reflect the actor model paradigm.