Slides from my talk at DDD Melbourne 2016 on a comparative overview of Akka.NET and Microsoft Orleans

2. Actor Model in .NET:
Akka.NET vs Microsoft Orleans
for the curious
William Tulloch
Lead Consultant – Readify
@wtulloch

3. Preamble
Concurrency and distributed applications

4. What is the Actor Model?

5. The Model of Actor Model
A way of reasoning about concurrent computation

6. What is the Actor Model
A way of reasoning about concurrent computation
Is inherently concurrent

7. The Model of Actor Model
Is a conceptual model for reasoning about concurrent
computation
Is inherently concurrent
Manages concurrency through message passing

8. The Model of Actor Model
Is a conceptual model for reasoning about concurrent
computation
Adopts the philosophy that everything is an actor
Is inherently concurrent
Manages concurrency through message passing

9. What is an Actor?
Lightweight
Never shares state
Communicates through asynchronous
messages
Has a mailbox to buffer messages
Processes one message at a time
Is a single-thread object

10. An Actor Can not exist on its own

11. Microsoft Orleans
&
Akka.NET

12. The overview
Akka.NET
• A port of Java/Scala Akka
• Open source
• Task Parallel Library
• Reactive methodology
• Can be run within an application,
on-prem or in the cloud(?)

13. The overview
Orleans
• Started by Microsoft Research
• Open source
• Task Parallel Library
• Reactive methodology
• Cloud-native
Akka.NET
• A port of Java/Scala Akka
• Open source
• Task Parallel Library
• Reactive methodology
• Can be run within an application, on-
prem or in the cloud(?)

14. Orleans versus Akka.NET

15. Hosting Actors
Image from Halo Orleans at build 2104
Orleans - SiloAkka - ActorSystem

16. Hosting Actors
Image from Halo Orleans at build 2104
Orleans - SiloAkka - ActorSystem

17. Actors versus Grains

18. Orleans: An Actor is Grain
Grain instances always exist virtually

19. Orleans: An Actor is Grain
Grain instances always exist virtually
Are created on demand

20. Orleans: An Actor is Grain
Grain instances always exist virtually
Are created on demand
Are location transparent

21. Orleans: An Actor is Grain
Grain instances always exist virtually
Are created on demand
Are location transparent
Every grain must have an Id

22. Akka.NET: An Actor is Actor
Must be explicitly created and stopped

23. Akka.NET: An Actor is Actor
Must be explicitly created and stopped
Are created in the context of their parent

24. Akka.NET: An Actor is Actor
Must be explicitly created and stopped
Are created in the context of their parent
Exposes a set of life-cycle hooks

25. Akka.NET: An Actor is Actor
Must be explicitly created and stopped
Are created in the context of their parent
Exposes a set of life-cycle hooks
Are location transparent
akka.tcp://Demo@127.0.0.1:12345/user/HelloWorld/$c

26. Creating grains and actors

27. Creating a grain

28. Orleans – creating a grain
• In Visual Studio create two projects
• One for your grain interfaces
• One for your grain implementations
• In both projects install the NuGet package
Microsoft.Orleans.OrleansCodeGenerator.build

29. Create a Grain interface
public interface IHelloWorld : IGrainWithIntegerKey
{
Task Greeting(string name);
Task<string> ReturnGreeting(string name);
}
Must implement one of the
following:
• IGrainWithIntegerKey
• IGrainWithGuidKey
• IGrainWithStringKey
• IGrainWithIntegerCompoundKey
• IGrainWithGuidCompoundKey

30. Create an implementation of the interface
public class HelloWorldGrain : Grain, IHelloWorld
{
public Task Greeting(string name)
{
Console.WriteLine($"Hi {name} from Orleans");
return TaskDone.Done;
}
public Task<string> ReturnGreeting(string name)
{
return Task.FromResult($"Hi {name} from Orleans");
}
}

31. Interacting with Grains
static async Task SendMessage(User user )
{
var helloWorld = GrainClient.GrainFactory.GetGrain<IHelloWorld>(0);
var response = await helloWorld.Greeting(user);
WriteLine(response);
}

32. Creating an Actor

33. Akka.Net – creating an actor
• In Visual Studio:
• Create a new class library
• Create a console application
• Import the core Akka.NET Nuget package: Akka

34. Create message
public class HelloUserMessage
{
public User User { get; }
public HelloUserMessage(User user)
{
User = user;
}
}

35. Create an actor
public class HelloWorldActor : ReceiveActor
{
private TimeSpan _waitPeriod;
public HelloWorldActor(TimeSpan waitPeriod)
{
_waitPeriod = waitPeriod;
Receive<HelloUserMessage>(m =>
{
var user = m.User;
Thread.Sleep(_waitPeriod);
WriteLine($"Hi {user.Id} {user.FirstName} nice to meet you [on thread ");
});
Receive<DataCompleted>(m => WriteLine("Data is completed"));
}

36. Using the actor
var system = ActorSystem.Create("demo")
var helloWorld = system.ActorOf(Props.Create(() => new HelloWorldActor()));
helloWorld.Tell(new HelloUserMessage(new User());
await system.Terminate();

37. Demo Hello World

38. Messages and Serialisation

39. Messages and Serialisation
public class UserMessage
{
public string FirstName { get;}
public string LastName { get;}
public UserMessage(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
}

40. Messages and serialisation
Task<string> Greeting(string firstName, string lastName);
Task<Immutable<byte[]>> ProcessRequest(Immutable<byte[]> request);

41. Messages and Serialisation
[Immutable]
public class User
{
public string FirstName { get;}
public string LastName { get;}
}

42. Bits and Pieces
“let it crash” and exception handling
Persisting state
Changing behaviour
Grains for everyone
Routing in Akka.NET
Clustering in Akka.NET

43. Summing up

44. Resources
Akka.NET
Akka.NET home: http://getakka.net/
Bootcamp: https://github.com/petabridge/akka-bootcamp
Orleans
Orleans Home: http://dotnet.github.io/orleans/
Halo-Orleans: https://channel9.msdn.com/Events/Build/2014/3-641
Comparing Akka.NET and Orleans: https://github.com/akka/akka-
meta/blob/master/ComparisonWithOrleans.md