Akka.NET Documentation

Akka.NET is an idiomatic .NET implementation of the actor model. It is designed for high-throughput, low-latency systems and can be used for:

• Concurrency: Actors process messages one-at-a-time in FIFO order, ensuring thread-safety for internal state without manual locks.
• Stream Processing: Using Akka.NET actors and Akka.Streams to process data or live event streams.
• Event-Driven Programming: Building applications where message-processing routines express the design.
• Event Sourcing and CQRS: Using Akka.Persistence for state re-entrancy/recoverability and Akka.Persistence.Query for CQRS projections.
• Location Transparency: Using Akka.Remote to allow actors in remote processes to communicate transparently.
• Distributed Systems: Using Akka.Cluster and Akka.Cluster.Sharding to build highly available, fault-tolerant systems.

Akka.NET provides Location Transparency through the RemoteActorRef. This means your actor code does not need to change whether an actor is local or remote.

• Behavior: A RemoteActorRef implements IActorRef, making a remote actor look and feel exactly like a local one.
• Implementation: When you Tell a message to a RemoteActorRef, the message is passed to a local EndpointWriter, which delivers it over the network to an EndpointReader on the remote side. The EndpointReader then routes it to the correct local actor.
• Replies: When a remote actor replies using Sender.Tell(), Akka.NET automatically creates a RemoteActorRef for the recipient, allowing the reply to travel back across the network transparently.

Akka.NET provides two primary ways to manage routees:

• Pools: The router creates and manages its own worker actors. You specify the number of instances, and the router handles creation. Because the router creates them, it also acts as their supervisor.
• Groups: You create the routees yourself and provide their paths to the router via configuration. The router sends messages to these paths using ActorSelection. Group routers do not have children and do not supervise the routees; if a routee dies, the group router is unaware.

Supervision Note: Pool routers use a custom strategy that returns Escalate for all exceptions. If the router's parent decides to restart the router, all pool workers will be recreated.

In remote deployments, an actor's supervisor might be a remote actor reference. In these cases, context.Parent (the supervisor reference) and context.Path.Parent (the parent node in the actor's path) will not represent the same actor.

Despite this, looking up a child's name within the supervisor will correctly find the actor on the remote node, preserving the logical hierarchy for unresolved actor references.

Persistence enables actors to save their state by persisting the events that lead to that state. This allows actors to restore their state after a crash or restart by replaying the event stream.

Common use cases:

• Implementing CQRS (Command Query Responsibility Segregation).
• Implementing Event Sourcing.
• Ensuring reliable message delivery in the face of network or system failures.

Akka Streams is a library for processing and transferring sequences of elements using bounded buffer space. This boundedness ensures that processing entities execute independently while only buffering a limited number of elements, preventing memory exhaustion.

Key Terminology

• Stream: An active process moving and transforming data.
• Element: The basic processing unit. Buffer sizes are expressed as a count of elements.
• Back-pressure: A non-blocking, asynchronous flow-control mechanism where consumers notify producers of their availability, slowing down the upstream to match consumption speeds.
• Graph: A description of the stream processing topology (the pathways elements follow).
• Processing Stage: The building blocks of a Graph (e.g., Select(), Where(), Merge, Broadcast).