Orleans: Microsoft's take on the actor pattern in .Net
Update: Orleans is now Open Source and available on GitHub https://github.com/dotnet/orleans
In September 2014 the Orleans Team anounced an update of their Developer Preview for the Orleans Framework. This is a good chance to look a Orleans and find out what is Orleans and where do I get started?
What is Orleans
After getting a glimpse in 2010 Microsoft released a CTP of their Orleans framework around Build 2014 . Orleans is a research project from Microsoft's Extreme Programing group and is meant to be a programming framework for the cloud. It's main purpose is to abstract away the burden of distributed systems and give developers a platform to concentrate on their business cases and not worrying about concurrency and distributed transactions and many more things related to distributed and cloud systems.
It is finally an official approach from Microsoft to cover the actor pattern. If you happen to look outside of the .Net space and look for scaleability on large message based systems you should have come across the actor pattern. Some of the well know implementations are Erlangs Actor model or Akka in the Scala space.
But what is an actor?
An actor is a small (lightweight) independend object. Actors life in single thread and can also hold state. They can mutate but only their private state no common shared state between other Actors. But Actors can communicate with each other via async messages. And the creation of an actor is controlled by the runtime which could be in one process, on one machine or spread over serveral machines. A more general introduction can also be found on wiki.
In fact these are all good incredients for distributed, concurrent systems. This is by all means no official definition but a good way how I defined it for myself and how to get started.
Back to Orleans!
The main concepts of Orleans can be summed up like this:
Grains:
A Grain is Microsofts take on the actor model. So a Grain = Actor. A Grain has a state and can communicate with other grains. It is important to know that every code is single threaded and methods need to use the .Net async and await Task Model. (Be aware that if you use the parallel task library you'll work in a different thread scope and things can be mixed up nasty).
Silos:
A silo can host multiple grains. Usually one server or worker role hosts one silo. Silos can be clustered on multiple servers. Silos life within the Orleans runtime which manages the creation of grains and their lifecycle.
Orleans clients:
Orleans clients are the entry point to the silos and the grains. It is basically non Orleans code that makes calls into the Orleans world to kick things off. An Orleans client needs to initialize and connect to the Orleans runtime.
Orleans runtime
Orleans runtime takes care about managing the silos. It's basically the foundation of the cloud framework "Orleans". It takes care of managing the infrastructure and is responsible for all the hiding which helps the developers to concentrate on the business logic.
If your are interessted to find out more you should check out following links.
More information here
You can find the orleans project page here
A show case talk at build 2014 demonstrating Orleans use on the Halo 4 back end can be found here
Right now the home of Orleans is on codeplex
Listen to .Dot Net Rocks! Episode #969 Microsoft Orleans with Richard Astbury
What's new with the refresh from September 2014
To find all details check out the What's new Post by the Orleans Team. But the most interesting thing is for sure that they relaxed the license situation. Screenshot from the What's new Post.
This is an exciting project. I am looking forward to see more and will definetly have an open eye on it.
Update: Orleans is now Open Source and available on GitHub https://github.com/dotnet/orleans