The actor model is a radically new concept for the majority of Akka.NET users, and therein lies some challenges. In this post we’re going to outline some of the common mistakes we see from beginners all the time when we take Akka.NET questions in Gitter chat, StackOverflow, and in our emails.
7. Making message classes mutable
One of the fundamental principles of designing actor-based systems is to make 100% of all message classes immutable, meaning that once you allocate an instance of that object its state can never be modified again.
The reason why immutable messages are crucial is because you can send the same message to 1000 actors concurrently and if each one of those actors makes a modification to the state of the message, all of those state changes are local to each actor.
There are no side effects to other actors when one actor modifies a message, which is why you should never need to use a lock inside an actor!
For example, this is an immutable message class:
public class Foo{ public Foo(string name, ReadOnlyList<int> points){ Name = name; Points = points; } public string Name {get; private set;} public ReadOnlyList<int> Points {get; private set;} } This class is immutable because:
stringis an immutable class - any modifications to it produce an entirely new string. The original is never modified, so to all of the other actors processing thisFooinstance
Lots of folks have been asking about Akka.NET and ASP.NET MVC integration on StackOverflow and in our Gitter chat room, so we thought it was time we created the definitive post on how to integrate these two amazing technologies together.
Note: Everything in this article also applies to Web API, Nancy, WCF, and ASP.NET WebForms.
Use Cases
So when would you want to use Akka.NET and a web framework like ASP.NET together at the same time?
Well, you might be like Joel in our “Akka.NET Goes to Wall Street” case study and need to manage concurrent reads / writes to a shared object model.
If you’re building anything resembling a chat room, web-based game, collaboration software, and more - then congratulations: managing concurrent mutations to shared state is something you’re going to have to do. Akka.NET actors are a tremendously better option than sprinkling your code with locks.
In general, what most people use Akka.NET for in the context of ASP.NET is to communicate with others network services the ASP.NET app might depend on, such as remote Windows Services via Akka.Remote and Akka.Cluster. This is especially useful if you need to do any sort of stateful web application programming, but that’s a story for a different day.
How to Start an ActorSystem in ASP.NET
If you’ve gone through Akka.NET Bootcamp, and you should if you haven’t yet, you know how to start an ActorSystem:
// config automatically loads from App.config / Web.config var actorSystem = ActorSystem.Create("myactorsystem"); var someActor = actorSystem.ActorOf(Props.Create(() => new FooActor
Our Akka.NET Virtual Meetup on August 12th was a huge success - we had about 100 users on the livestream with us and the recording of the meetup has been viewed several hundred times since.
One of the topics I covered during my presentation about using Akka.NET in production at MarkedUp was the concept of stateful applications built with actors - the idea that state can reside within your application rather than outside of it by default, and how it was this idea that made our marketing automation product possible to build.
This tweet from an attendee sums up the realization well:
@Aaronontheweb A key take away for me is Actors are stateful and I do not have to get/post constantly from Redis. Wow that is liberating.
— akshay123 (@akshay123) August 12, 2015Exactly right! Actors can be stateful - and that means we no longer have to factor round-trip times to SQL Server, Redis, Cassandra, or whatever into the design of our applications. The application already has the state it needs to do its job by the time a request arrives!
The Limitations of Stateless Design
The traditional way of developing web applications is stateless - and that’s a natural consequence of HTTP, itself an inherently stateless protocol.
Petabridge
© 2015-2018 Petabridge, LLC