NOTE: These are the official release notes from https://github.com/akkadotnet/akka.net/releases/tag/v0.8, but with some slight formatting changes.
Thanks to some amazing effort from individual contributor (@jcwrequests), Akka.NET now has direct dependency injection support for Ninject, Castle Windsor, and AutoFac.
Let’s dive in!
How do you keep your actor system from falling apart when things go wrong?
The short answer is Supervision.
“Look at this mess you made. Now clean it up and start over!”
Just kidding. You’re doing great. Relax.
But I bet you’ve heard (and probably said) something similar before. That’s similar to supervision in the actor model: a parent monitors its children for errors, and decides how to clean up messes when they happen.
Supervision is the basic concept that allows your actor system to quickly isolate and recover from failures.
Supervision from the top to the bottom of the actor hierarchy ensures that when part of your application encounters an unexpected failure (unhandled exception, network timeout, etc.) those failures will be contained to only the affected part of your actor hierarchy. All other actors will keep on working as though nothing happened. We call this “failure isolation.”
How is this accomplished? Let’s find out…
One of the first questions developers ask once they learn how Akka.NET actors work is
If actors can only process one message at a time, can I still use
asyncmethods orTask<T>objects inside my actors?
The answer is yes! You can still use asynchronous methods and Task<T> objects inside your actors - using the PipeTo pattern!
Since Akka.NET 1.0 was released, Akka.NET actors have fully supported async / await inside actors. But there’s a catch involved. We still strongly recommend PipeTo over asyc / await for performance and cohesion reasons but there are scenarios where the latter makes life easier. Keep reading!
So actors process the contents of their inbox like this:
The actor’s mailbox pushes a new message into the actor’s OnReceive method once the previous call to OnReceive exits.
This is an important concept, because this is how Akka.NET enforces thread-safety for all of the code that executes inside an actor - by making sure an actor’s message processing code (
OnReceive) can only be run one invocation at a time.
That being said, it’s still possible to take advantage of async methods and methods that return Task<T> objects inside the OnReceive method - you just have to use the PipeTo extension method!
© 2017 Petabridge, LLC