Namespace Akka.Actor

Classes

ActorCell

INTERNAL API.

The hosting infrastructure for actors.

ActorIdentity

Response to the Identify message, get identity by Sender

ActorInitializationException

This exception is thrown when the initialization logic for an Actor fails.

ActorInterruptedException

This exception is thrown when an actor is interrupted in the midst of processing messages.

This is an exception typically thrown when the underlying dispatcher's threads are aborted.

ActorKilledException

This exception is thrown when a Kill message has been sent to an Actor. DefaultDecider will by default stop the actor.

ActorNotFoundException

This exception is thrown when an Actor can not be found.

Actor path is a unique path to an actor that shows the creation path up through the actor tree to the root actor. ActorPath defines a natural ordering (so that ActorRefs can be put into collections with this requirement); this ordering is intended to be as fast as possible, which owing to the bottom-up recursive nature of ActorPath is sorted by path elements FROM RIGHT TO LEFT, where RootActorPath > ChildActorPath in case the number of elements is different. Two actor paths are compared equal when they have the same name and parent elements, including the root address information. That does not necessarily mean that they point to the same incarnation of the actor if the actor is re-created with the same path. In other words, in contrast to how actor references are compared the unique id of the actor is not taken into account when comparing actor paths.

ActorPath.Surrogate

This class represents a surrogate of an ActorPath. Its main use is to help during the serialization process.

ActorProducerPipeline

TBD

ActorProducerPipelineResolver

Class used to resolving actor producer pipelines depending on actor type.

ActorProducerPluginBase

Base actor producer pipeline plugin class.

ActorProducerPluginBase<TActor>

Base generic actor producer pipeline plugin class.

ActorRefBase

Base implementation for IActorRef implementations.

ActorRefBase.Surrogate

This class represents a surrogate of a ActorRefBase router. Its main use is to help during the serialization process.

ActorRefExtensions

This class contains extension methods used for working with ActorRefs.

ActorRefFactoryExtensions

This class contains extension methods used for working with IActorRefFactory.

ActorRefFactoryShared

This class contains implementations originally found in Akka´s trait ActorRefFactory in ActorRefProvider.scala https://github.com/akka/akka/blob/master/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala#L180 IActorRefFactory corresponds to that trait, but since it is an interface it cannot contain any code, hence this class.

ActorRefImplicitSenderExtensions

Extension method class. Used to deliver messages to IActorRef instances via Tell(IActorRef, Object) and Forward(IActorRef, Object) and pass along information about the current sender.

ActorRefs

Utility class for working with built-in actor references

ActorRestarted

Emitted when an actor restarts.

ActorSelection

This class represents a logical view of a section of an ActorSystem's tree of actors that allows for broadcasting of messages to that section.

ActorSelectionMessage

Used to deliver messages via ActorSelection.

ActorStarted

ActorStashPlugin

TBD

ActorStopped

Event emitted when actor shuts down.

ActorSystem

An actor system is a hierarchical group of actors which share common configuration, e.g. dispatchers, deployments, remote capabilities and addresses. It is also the entry point for creating or looking up actors. There are several possibilities for creating actors (see Props for details on props):

system.ActorOf(props, "name");
system.ActorOf(props);
system.ActorOf(Props.Create(typeof(MyActor)), "name");
system.ActorOf(Props.Create(() => new MyActor(arg1, arg2), "name");

Where no name is given explicitly, one will be automatically generated.

Important Notice: This class is not meant to be extended by user code.

ActorSystemWithExtensions

This class contains extension methods used for resolving ActorSystem extensions.

Address

The address specifies the physical location under which an Actor can be reached. Examples are local addresses, identified by the ActorSystem's name, and remote addresses, identified by protocol, host and port.

This class is sealed to allow use as a case class (copy method etc.); if for example a remote transport would want to associate additional information with an address, then this must be done externally.

Address.AddressSurrogate

This class represents a surrogate of an Address. Its main use is to help during the serialization process.

AkkaException

This exception provides the base for all Akka.NET specific exceptions within the system.

AllForOneStrategy

This class represents a fault handling strategy that applies a Directive to all child actors when one child fails.

AllForOneStrategy.AllForOneStrategySurrogate

This class represents a surrogate of a AllForOneStrategy router. Its main use is to help during the serialization process.

AskTimeoutException

This exception is thrown when an Ask operation times out.

BootstrapSetup

Core bootstrap settings for the ActorSystem, which can be created using one of the static factory methods on this class.

Cancelable

A ICancelable that wraps a CancellationTokenSource. When canceling this instance the underlying CancellationTokenSource is canceled as well.

CancelableExtensions

Provides extensions methods for ICancelable.

ChildActorPath

Actor paths for child actors, which is to say any non-guardian actor.

CoordinatedShutdown

An ActorSystem extension used to help coordinate and sequence shutdown activities during graceful termination of actor systems, plugins, and so forth.

CoordinatedShutdown.ActorSystemTerminateReason

The shutdown was initiated by an ActorSystem termination hook

CoordinatedShutdown.ClrExitReason

The shutdown was initiated by a CLR shutdown hook

CoordinatedShutdown.ClusterDowningReason

The shutdown was initiated by Cluster downing.

CoordinatedShutdown.ClusterJoinUnsuccessfulReason

The shutdown was initiated by a failure to join a seed node.

CoordinatedShutdown.ClusterLeavingReason

The shutdown was initiated by Cluster leaving.

CoordinatedShutdown.Reason

Reason for the shutdown, which can be used by tasks in case they need to do different things depending on what caused the shutdown. There are some predefined reasons, but external libraries applications may also define other reasons.

CoordinatedShutdown.UnknownReason

The reason for the shutdown was unknown. Needed for backwards compatibility.

CoordinatedShutdownExtension

Used to register the CoordinatedShutdown extension with a given ActorSystem.

DateTimeOffsetNowTimeProvider

The default ITimeProvider implementation for Akka.NET when not testing.

DeadLetterActorRef

Class DeadLetterActorRef.

DeathPactException

This exception is thrown by an Actor that receives a Terminated(someActor) message that it doesn't handle itself, effectively crashing the Actor and escalating to the supervisor.

Decider

This class contains methods used to simplify working with different *Deciders.

DefaultSupervisorStrategy

TBD

Deploy

This class represents a configuration object used in the deployment of an actor.

Deploy.DeploySurrogate

This class represents a surrogate of a Deploy configuration object. Its main use is to help during the serialization process.

DeployableDecider

TBD

Deployer

Used to configure and deploy actors.

DirectiveExtensions

This class contains extension methods used for working with directives.

EmptyLocalActorRef

TBD

EventStreamActor

Class EventStreamActor.

ExtendedActorSystem

More powerful interface to the actor system’s implementation which is presented to extensions (see IExtension). Important Notice:

This class is not meant to be extended by user code. If you want to actually roll your own Akka, beware that you are completely on your own in that case!

ExtensionIdProvider<T>

This class represents the base provider implementation for creating, registering and retrieving extensions within an ActorSystem.

Failure

Represents a single failure.

Failures

Collection of failures, used to keep track of how many times a given actor has failed.

FSM<TState, TData>

Finite state machine (FSM) actor.

FSM<TState, TData>.TransformHelper

TBD

FSMBase

TBD

FSMBase.CurrentState<TS>

Message type which is sent directly to the subscriber Actor in FSMBase.SubscribeTransitionCallBack before sending any FSMBase.Transition<TS> messages.

FSMBase.Failure

Signifies that the FSM<TState, TData> is shutting itself down because of an error, e.g. if the state to transition into does not exist. You can use this to communicate a more precise cause to the OnTermination(Action<FSMBase.StopEvent<TState, TData>>) block.

FSMBase.LogEntry<TS, TD>

Log entry of the ILoggingFSM - can be obtained by calling

FSMBase.Normal

Default FSMBase.Reason if calling Stop().

FSMBase.Reason

Reason why this FSM<TState, TData> is shutting down

FSMBase.Shutdown

Reason given when someone as calling Stop() from outside; also applies to ActorSystem supervision directive.

FSMBase.State<TS, TD>

This captures all of the managed state of the FSM<TState, TData>: the state name, the state data, possibly custom timeout, stop reason, and replies accumulated while processing the last message.

FSMBase.StateTimeout

Used in the event of a timeout between transitions

FSMBase.StopEvent<TS, TD>

Class representing the state of the FSM<TState, TData> within the OnTermination block.

FSMBase.SubscribeTransitionCallBack

Send this to an FSMBase.SubscribeTransitionCallBack to request first the FSMBase.UnsubscribeTransitionCallBack followed by a series of FSMBase.Transition<TS> updates. Cancel the subscription using FSMBase.CurrentState<TS>.

FSMBase.Transition<TS>

Message type which is used to communicate transitions between states to all subscribed listeners (use FSMBase.SubscribeTransitionCallBack)

FSMBase.UnsubscribeTransitionCallBack

Unsubscribe from FSMBase.SubscribeTransitionCallBack notifications which were initialized by sending the corresponding FSMBase.Transition<TS>.

FutureActorRef<T>

INTERNAL API.

ActorRef implementation used for one-off tasks.

Futures

Extension method class designed to create Ask support for non-ActorRef objects such as ActorSelection.

GracefulStopSupport

GracefulStop extensions.

GuardianActor

Class GuardianActor.

HashedWheelTimerScheduler

This IScheduler implementation is built using a revolving wheel of buckets with each bucket belonging to a specific time resolution. As the "clock" of the scheduler ticks it advances to the next bucket in the circle and processes the items in it, and optionally reschedules recurring tasks into the future into the next relevant bucket.

There are akka.scheduler.ticks-per-wheel initial buckets (we round up to the nearest power of 2) with 512 being the initial default value. The timings are approximated and are still limited by the ceiling of the operating system's clock resolution.

Further reading: http://www.cs.columbia.edu/~nahum/w6998/papers/sosp87-timing-wheels.pdf Presentation: http://www.cse.wustl.edu/~cdgill/courses/cs6874/TimingWheels.ppt

Identify

Request to an ICanTell to get back the identity of the underlying actors.

IllegalActorNameException

This exception is thrown when an Actor with an invalid name is deployed.

IllegalActorStateException

This exception is thrown when a core invariant in the Actor implementation has been violated. For instance, if you try to create an Actor that doesn't inherit from ActorBase.

Inbox

TBD

InvalidActorNameException

This exception is thrown when the actor name is invalid.

InvalidMessageException

This exception is thrown when an invalid message is sent to an Actor.

note

Currently only null is an invalid message.

Kill

Sending an Kill message to an actor causes the actor to throw an ActorKilledException when it processes the message, which gets handled using the normal supervisor mechanism.

See also PoisonPill which causes the actor to stop when the PoisonPill is processed, without throwing an exception, and Stop(IActorRef) which causes the actor to stop without processing any more messages.

LocalActorRef

A local actor reference that exists inside the same process as the current ActorSystem.

LocalActorRefProvider

Class LocalActorRefProvider. This class cannot be inherited.

LocalOnlyDecider

TBD

LocalScope

This class represents a binding of an actor deployment to a local system.

LocalScope.LocalScopeSurrogate

This class represents a surrogate of a LocalScope binding. Its main use is to help during the serialization process.

LoggerInitializationException

This exception is thrown when there was a problem initializing a logger.

Nobody

This is an internal look-up failure token, not useful for anything else.

Nobody.NobodySurrogate

A surrogate for serializing Nobody.

OneForOneStrategy

This class represents a fault handling strategy that applies a Directive to the single child actor that failed.

OneForOneStrategy.OneForOneStrategySurrogate

This class represents a surrogate of a OneForOneStrategy router. Its main use is to help during the serialization process.

PipeToSupport

Creates the PipeTo pattern for automatically sending the results of completed tasks into the inbox of a designated Actor

PoisonPill

Sending a PoisonPill to an actor will stop the actor when the message is processed. PoisonPill is enqueued as ordinary messages and will be handled after messages that were already queued in the mailbox.

See also Kill which causes the actor to throw an ActorKilledException when it processes the message, which gets handled using the normal supervisor mechanism, and Stop(IActorRef) which causes the actor to stop without processing any more messages.

PostRestartException

This exception is thrown when the Actor constructor or PostRestart(Exception) method fails during a restart attempt.

PreRestartException

This exception is thrown when the PreRestart(Exception, Object) method fails during a restart attempt.

note

This exception is not propagated to the supervisor, as it originates from the already failed instance, hence it is only visible as log entry on the event stream.

Props

This class represents a configuration object used in creating an actor. It is immutable and thus thread-safe.

private Props props = Props.Empty();
private Props props = Props.Create(() => new MyActor(arg1, arg2));

private Props otherProps = props.WithDispatcher("dispatcher-id");
private Props otherProps = props.WithDeploy(deployment info);

Props.PropsSurrogate

This class represents a surrogate of a Props configuration object. Its main use is to help during the serialization process.

ProviderSelection

INTERNAL API

ProviderSelection.Cluster

ProviderSelection.Custom

ProviderSelection.Local

ProviderSelection.Remote

ReceiveActor

TBD

ReceiveTimeout

This message is sent to an actor that has set a receive timeout, either by calling Context.SetReceiveTimeout or SetReceiveTimeout and no message has been sent to the actor during the specified amount of time.

RelativeActorPath

Extractor class for so-called "relative actor paths" - as in "relative URI", not "relative to some other actors."

Examples:

"grand/child"
"/user/hello/world"

RemoteScope

This class represents a binding of an actor deployment to a remote system. Actors in this scope are deployed to a specified Address.

RepointableActorRef

TBD

RootActorPath

Actor paths for root guardians, such as "/user" and "/system"

RootGuardianSupervisor

Top-level anchor for the supervision hierarchy of this actor system. Note: This class is called theOneWhoWalksTheBubblesOfSpaceTime in Akka

SchedulerBase

Abstract base class for implementing any custom IScheduler implementation used by Akka.NET.

All constructed schedulers are expected to support the Config and ILoggingAdapter arguments provided on the default constructor for this class.

SchedulerException

An AkkaException that is thrown by the Schedule* methods when scheduling is not possible, e.g. after shutting down the IScheduler.

SchedulerExtensions

This class contains extension methods used for working with the different schedulers within the system.

Scope

This class provides base functionality when defining a system binding (e.g. local/remote/cluster) used during actor deployment.

SelectChildName

Class SelectChildName.

SelectChildPattern

Class SelectChildPattern.

SelectChildRecursive

SelectionPathElement

Class SelectionPathElement.

SelectParent

Class SelectParent.

Settings

This class represents the overall ActorSystem settings which also provides a convenient access to the Config object. For more detailed information about the different possible configuration options, look in the Akka.NET Documentation under Configuration (https://getakka.net/articles/configuration/config.html).

StashFactory

Static factor used for creating Stash instances

StashOverflowException

This exception is thrown when the size of the Stash exceeds the capacity of the stash.

Status

Classes for passing status back to the sender. Used for internal ACKing protocol, but also exposed as a utility class for user-specific ACKing if needed.

Status.Failure

Indicates the failure of some operation that was requested and includes an Exception describing the underlying cause of the problem.

Status.Success

Indicates the success of some operation which has been performed

StoppingSupervisorStrategy

TBD

SupervisorStrategy

Base class for supervision strategies

SupervisorStrategyConfigurator

TBD

SystemGuardianActor

System guardian.

Root actor for all actors under the /system path.

Terminated

When Death Watch is used, the watcher will receive a Terminated(watched) message when watched is terminated. Terminated message can't be forwarded to another actor, since that actor might not be watching the subject. Instead, if you need to forward Terminated to another actor you should send the information in your own message.

TerminatedProps

This class represents a specialized Props used when the actor has been terminated.

UntypedActor

Class UntypedActor.

UntypedActorWithStash

Actor base class that should be extended to create an actor with a stash.

The stash enables an actor to temporarily stash away messages that can not or should not be handled using the actor's current behavior.

Note that the subclasses of UntypedActorWithStash by default request a Deque based mailbox since this class implements the IRequiresMessageQueue<T> marker interface.

You can override the default mailbox provided when IDequeBasedMessageQueueSemantics are requested via config:

akka.actor.mailbox.requirements {
    "Akka.Dispatch.IDequeBasedMessageQueueSemantics" = your-custom-mailbox
}

Alternatively, you can add your own requirement marker to the actor and configure a mailbox type to be used for your marker.

For a Stash based actor that enforces unbounded deques see UntypedActorWithUnboundedStash. There is also an unrestricted version UntypedActorWithUnrestrictedStash that does not enforce the mailbox type.

UntypedActorWithUnboundedStash

Actor base class with Stash that enforces an unbounded deque for the actor. See UntypedActorWithStash for details on how Stash works.

UntypedActorWithUnrestrictedStash

Actor base class with Stash that does not enforce any mailbox type. The proper mailbox has to be configured manually, and the mailbox should extend the IDequeBasedMessageQueueSemantics marker interface. See UntypedActorWithStash for details on how Stash works.

WatchAsyncSupport

WatchAsync extensions

WrappedMessage

Structs

Envelope

Envelope class, represents a message and the sender of the message.

FSMBase.Event<TD>

All messages sent to the FSM<TState, TData> will be wrapped inside an FSMBase.Event<TD>, which allows pattern matching to extract both state and data.

Interfaces

IActionScheduler

This interface defines a scheduler that is able to execute actions on a set schedule.

IActorContext

TBD

IActorProducerPlugin

Plugin interface used to define

IActorRef

An actor reference. Acts as a handle to an actor. Used to send messages to an actor, whether an actor is local or remote. If you receive a reference to an actor, that actor is guaranteed to have existed at some point in the past. However, an actor can always be terminated in the future.

If you want to be notified about an actor terminating, call IActorContext.Watch on this actor and you'll receive a Terminated message when the actor dies or if it is already dead.

IActorRefFactory

Interface IActorRefFactory

IActorRefProvider

The Actor Reference Provider API.

The factory used to produce and create IActorRef instances used inside an ActorSystem.

IActorStash

Marker interface for adding stash support

IActorTelemetryEvent

A set of events designed to provide some basic telemetry functions for monitoring actor lifecycles.

We want to track actor starts, stops, and restarts. More detailed metrics, such as mailbox size or message processing rates will require something like Phobos [https://phobos.petabridge.com/].

IAdvancedScheduler

TBD

IAutoReceivedMessage

Marker trait to show which Messages are automatically handled by Akka.NET

ICancelable

Signifies something that can be canceled

ICanTell

A shared interface for both IActorRef and ActorSelection, both of which can be sent messages via the Tell(Object, IActorRef) command.

ICanWatch

TBD

IDateTimeOffsetNowTimeProvider

Marks that an ITimeProvider uses UtcNow, i.e. system time, to provide Now.

IDecider

This interface defines the methods used by a Decider to map an Exception to a Directive.

IExtension

This interface is used to mark an object as an ActorSystem extension.

IExtensionId

This interface is used to distinguish unique ActorSystem extensions.

IExtensionId<T>

This interface is used to distinguish unique ActorSystem extensions.

IInboxable

IInboxable is an actor-like object to be listened by external objects. It can watch other actors lifecycle and contains inner actor, which could be passed as reference to other actors.

IIndirectActorProducer

This interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the Actor subclass. It can be used to allow a dependency injection framework to determine the actual actor class and how it shall be instantiated.

IInternalActor

Contains things needed by the framework

ILoggingFSM

Marker interface to let the setting "akka.actor.debug.fsm" control if logging should occur in FSM<TState, TData>

ILogReceive

Interface ILogReceive

INoSerializationVerificationNeeded

Marker Interface INoSerializationVerificationNeeded, this interface prevents implementing message types from being serialized if configuration setting 'akka.actor.serialize-messages' is "on"

INotInfluenceReceiveTimeout

Marker interface to indicate that a message should not reset the receive timeout.

IPossiblyHarmful

Marker interface to indicate that a message might be potentially harmful; this is used to block messages coming in over remoting.

IRepointableRef

INTERNAL API

RepointableActorRef (and potentially others) may change their locality at runtime, meaning that isLocal might not be stable. RepointableActorRef has the feature that it starts out "not fully started" (but you can send to it), which is why IsStarted features here; it is not improbable that cluster actor refs will have the same behavior.

IRunnableScheduler

INTERNAL API

Convenience API for working with IRunnable

IScheduler

TBD

IStash

Public interface used to expose stash capabilities to user-level actors

ITellScheduler

This interface defines a scheduler that is able to send messages on a set schedule.

ITimeProvider

Time provider used by the scheduler to obtain the current time.

ITimerScheduler

Support for scheduled "Self" messages in an actor.

Timers are bound to the lifecycle of the actor that owns it, and thus are cancelled automatically when it is restarted or stopped.

ITimerScheduler is not thread-safe, i.e.it must only be used within the actor that owns it.

IUntypedActorContext

Interface IUntypedActorContext

IWithBoundedStash

Lets the StashFactory know that this Actor needs stash support with restricted storage capacity You need to add the property:

public IStash Stash { get; set; }

IWithStash

The IWithStash interface enables an actor to temporarily stash away messages that can not or should not be handled using the actor's current behavior.

Note that the IWithStash interface can only be used together with actors that have a deque-based mailbox. By default Stash based actors request a Deque based mailbox since the stash interface extends IRequiresMessageQueue<T>.

You can override the default mailbox provided when IDequeBasedMessageQueueSemantics are requested via config:

akka.actor.mailbox.requirements {
    "Akka.Dispatch.IBoundedDequeBasedMessageQueueSemantics" = your-custom-mailbox
}

Alternatively, you can add your own requirement marker to the actor and configure a mailbox type to be used for your marker.

For a Stash that also enforces unboundedness of the deque see IWithUnboundedStash. For a Stash that does not enforce any mailbox type see IWithUnrestrictedStash.

Enums

Directive

This enumeration defines the different types of directives used by the supervisor when dealing with child actors that fail.