Akka.net versus microsoft orleans

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

Preamble
Concurrency and distributed applications

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

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

Is a conceptual model for reasoning about concurrent
computation
Manages concurrency through message passing

Is a conceptual model for reasoning about concurrent
computation
Adopts the philosophy that everything is an actor
Manages concurrency through message passing

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

An Actor Can not exist on its own

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(?)

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

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

Orleans: An Actor is Grain
Grain instances always exist virtually

Are created on demand

Are location transparent

Every grain must have an Id

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

Exposes a set of life-cycle hooks
akka.tcp://Demo@127.0.0.1:12345/user/HelloWorld/$c

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

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

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");
}
}

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

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

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

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"));
}

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();

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

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

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

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

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

Akka.net versus microsoft orleans

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Akka.net versus microsoft orleans

Similaire à Akka.net versus microsoft orleans (20)

Dernier

Dernier (20)

Akka.net versus microsoft orleans

Notes de l'éditeur