Reactive Programming in .Net - actorbased computing with Akka.Net

Reactive Manifest und Akka.Net

Wie kommen wir da hin? Reactive Manifesto

event Handling data flow graph processing
System Architecure
zuverlässige skalierbare
elastic
message-driven
resilient
responsive
http://www.reactivemanifesto.org/de

Elastic
react to load
Message-Driven
Services / Components Interaction
Resilient
react to failures
Responsive
react to users
Reactive System
goal
methods
concepts

Carl Hewitt (1973),
Actor Model of Computation:
Scalable Robust Information Systems

• Typesafe: Actor-Framework
• Scala (JVM) => Java
• ausgereiftes, erprobtes Framework
• Akka.Net
• Portierung von Akka (2013)
• Aaron Stannard Roger Johansson
• http://getakka.net
akka.net

Concurreny
 Scalability
 Fault-tolerance
Simpler
 Programming Model
 Managed Runtime
 Open Source Distribution
…with a single unified

http://doc.akka.io/docs/akka/current/intro/use-cases.html

PM> Install-Package Akka
nuget
using Akka.Actor;
using (var actorSystem = ActorSystem.Create("MyActorSystem"))
{
// universe
}
nur innerhalb dieses Blocks
„leben“ Aktoren
var actorSystem = ActorSystem.Create("MyActorSystem"));
// universe
actorSystem.WhenTerminated.Wait(); // wait for termination-task
actorSystem.AwaitTermination(); // deprecated
oder

// universe
IActorRef myActor = actorSystem.ActorOf(
Props.Create(() => new MyActor())
);
using (var actorSystem = ActorSystem.Create("MyActorSystem"))
{
}
// talk to the actor
myActor.Tell(new SomeMessage("rise up slave..."));
erzeuge AktorSystem
fordere spezifischen
Aktor an
sprich mit dem erhaltenen
Aktor

public class SomeMessage
{
public SomeMessage(string name)
{
Name = name;
}
public string Name { get; private set; }
}
public class MyActor : ReceiveActor
{
public MyActor()
{
Receive<string>(message => {
Sender.Tell(message);
});
Receive<SomeMessage>(message => {
// react to message
});
}
}
alle Nachrichten sind
immutable
Nachrichten werden
prinzipiell nach ihrem
Typ unterschieden *
* es geht fein-granularer
und abstrakter

Receive<string>(s => Console.WriteLine("Received string: " + s)); //1
Receive<int>(i => Console.WriteLine("Received integer: " + i)); //2
IActorRef sender = Sender;

//Receive using Funcs
Receive<string>(s =>
{
if (s.Length > 5) {
Console.WriteLine("1: " + s);
return true;
}
return false;
});
Receive<string>(s => Console.WriteLine("2: " + s));
//predicates
Receive<string>(s => s.Length > 5, s => Console.WriteLine("1: " + s)); //1
Receive<string>(s => Console.WriteLine("3: " + s));
//handler priority
Receive<string>(s => Console.WriteLine("3: " + s)); //3

public class MyActor : ActorBase
{
public MyActor()
{
//nothing todo
}
protected override bool Receive(object _message)
{
//handle different messages
var message = _message as SomeMessage;
if(message != null)
{
return false;
}
return false;
}
}
Nachrichten werden
prinzipiell nach ihrem
Typ unterschieden *
* es geht fein-granularer
und abstrakter

using Akka.Actor;
public class MyUntypedActor : UntypedActor
{
protected override void OnReceive(object message)
{
var msg = message as Messages.InputError;
if (msg != null)
{
// cool, its for me
}
else
{
Unhandled(message); //from ActorBase
}
}
}
• anders als beim ReceiveActor müssen nicht behandelte
Nachrichten selbst als solche markiert werden

IActorRef friend = Context.ActorOf(Props.Create(() => new MyReceiveActor()));
sender.Tell(new SomeMessage("Re: " + message.Name));
IActorRef friend = ...
friend.Tell(new SomeMessage("Forward: " + message.Name), sender);
IActorRef friend = ...
friend.Forward(new SomeMessage("Forward: " + message.Name)); forward
tell + explicit sender
tell

event-driven thread
Actor
Behavior
Mailbox
State
Childs
Supervisor-Strategy
ActorRef 1 2 34
Transport [Akka]
IActorRef myActor = ...
myActor.Tell(new Message("four"));
• IActorRef: handle oder reference auf einen Actor
• Nachrichten werden niemals direkt an einen
Actor gesendet
• ActorSystem fügt Metadaten (Sender, Empfänger) hinzu
• ActorSystem garantiert Ankunft jeder Nachricht *

IActorRef
• Actor Namen sind optional
• best practise: named actors
Create
Look up
IActorRef myActor = actorSystem.ActorOf(
Props.Create(() => new MyActor()),
"myactor1"
);
• adressierbar über ActorPath
• Actoren bilden eine Hierarchy
Parent
Children
Sender
ActorSelection randomActor =
actorSystem.ActorSelection("akka://ActorSys/user/myactor1");

Props props1 = Props.Create(typeof(MyActor));
Props props2 = Props.Create(() => new MyActor());
Props props3 = Props.Create<MyActor>();
typeof Syntax
lambda Syntax
generic Syntax
• einzigerWeg um Parameter
zu übergeben
• unsicher
Context.ActorOf(props2);
actorSystem.ActorOf(props2);
aus einem Actor heraus:
direkt im ActorSystem:
-> erzeugt HierarchieVerwendung

akka.tcp://MySystem@localhost:9001/user/actorName1
Protocol
ActorSystem
Akka
Path
Akka Remote
Address

/syst
em
Guardians
/a1 /a2
top level
actor
/b1
/c1 /cx
/b2
/c2 /cx
akka://ActorSystem/user
akka://ActorSystem/user/a1
akka://ActorSystem/user/a1/b2
akka://ActorSystem/user/a1/*/cx
/user
/

parent
parent
Failure
SupervisionStrategy
• Restart, Stop, Resume, Escalate
• 2 Default-Strategien: One-For-One und All-For-One

• erklärtes Ziel ist es Fehler einzugrenzen:
• localizing the failure: fehleranfälligen Code
The critical thing to know here is that *whatever action is
taken on a parent propagates to its children*. If a parent is
halted, all its children halt. If it is restarted, all its children
restart.

protected override SupervisorStrategy SupervisorStrategy() {
// immer die gleiche Entscheidung
return new OneForOneStrategy(
maxNrOfRetries: 10,
withinTimeRange: TimeSpan.FromSeconds(30),
localOnlyDecider: exception =>
{
Console.WriteLine("*** Supervision: Restart");
return Directive.Restart;
}
);
}

Clients
[SignalR]
Clients
[SignalR]
Clients
[SignalR]
GameHub
[SignalR]
Bridge-
Actor
[Akka]
GameCtrl-
Actor
[Akka]
Player-
Actor
[Akka]
internet
join
attack attack
refreshState
sendState
changeHealth
join
attack

Clients
[SignalR]
Clients
[SignalR]
Clients
[SignalR]
GameHub
[SignalR]
internet
join
attack
ActorSystem
[Akka]

public class MvcApplication : HttpApplication {
protected void Application_Start()
{
//ASP.Net Stuff: Filters, Routes, ...
//Akka init
GameActorSystem.Create();
}
void Application_End()
{
GameActorSystem.Shutdown();
}
}

public static class GameActorSystem
{
private static ActorSystem ActorSystem;
private static IGameEventsPusher _gameEventsPusher;
public static void Create()
{
_gameEventsPusher = new SignalRGameEventPusher();
ActorSystem = Akka.Actor.ActorSystem.Create("GameSystem");
ActorReferences.GameController = ActorSystem.ActorOf<GameControllerActor>();
ActorReferences.SignalRBridge = ActorSystem.ActorOf(
Props.Create(() =>
new SignalRBridgeActor(_gameEventsPusher, ActorReferences.GameController)),
"SignalRBridge„
);
}
public static void Shutdown()
{
ActorSystem.Shutdown();
ActorSystem.AwaitTermination(TimeSpan.FromSeconds(1));
}
public static class ActorReferences ...
}

class SignalRGameEventPusher : IGameEventsPusher {
private static readonly IHubContext _gameHubContext;
static SignalRGameEventPusher() //static CTOR
{
_gameHubContext = GlobalHost.ConnectionManager.GetHubContext<GameHub>();
}
public void PlayerJoined(string playerName, int playerHealth)
{
_gameHubContext.Clients.All.playerJoined(playerName, playerHealth);
}
public void UpdatePlayerHealth(string playerName, int playerHealth)
{
_gameHubContext.Clients.All.updatePlayerHealth(playerName, playerHealth);
}
}
GameHub
[SignalR]
ActorSystem
[Akka]
playerJoined
updatePlayerHealth
Clients
Clients
Clients

public class GameHub : Hub
{
public void JoinGame(string playerName)
{
GameActorSystem
.ActorReferences
.SignalRBridge
.Tell(new JoinGameMessage(playerName));
}
public void Attack(string playerName)
{
GameActorSystem
.ActorReferences
.SignalRBridge
.Tell(new AttackPlayerMessage(playerName));
}
}
GameHub
[SignalR]
join
attack
ActorSystem
[Akka]

Closed
Open
Deleted
open close
delete

Reactive Programming in .Net - actorbased computing with Akka.Net

Recommended

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Reactive Programming in .Net - actorbased computing with Akka.Net (20)

Recently uploaded (20)

Reactive Programming in .Net - actorbased computing with Akka.Net

Editor's Notes