Class ActorBase.

Class ActorCell.

Thrown when a Kill message has been sent to an actor. DefaultDecider(Exception) will by default stop the actor.

Class ActorNotFoundException.

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.

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

Base actor producer pipeline plugin class.

Base generic actor producer pipeline plugin class.

An extension method class for working with ActorRefs

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 ActorRefFactory corresponds to that trait, but since it is an interface it cannot contain any code, hence this class.

Class ActorSelection.

Class ActorSelectionMessage.

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 [[Akka.Actor.Props]] for details on `props`): Where no name is given explicitly, one will be automatically generated. Important Notice: This class is not meant to be extended by user code.

Static helper class used for resolving extensions

Class Address.

Class AkkaException.

Class AllForOneStrategy. This class cannot be inherited.

Class ChildActorPath.

Class DeadLetterActorRef.

A DeathPactException 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.

Class EventStreamActor.

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

Class ExtensionBase.

Represents a single failure.

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

Finite state machine (FSM) actor.

Message type which is sent directly to the subscriber Actor in FSMBaseSubscribeTransitionCallBack before sending any FSMBaseTransitionTS messages.

All messages sent to the FSMTState, TData will be wrapped inside an FSMBaseEventTD, which allows pattern matching to extract both state and data.

Signifies that the FSMTState, 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(ActionFSMBaseStopEventTState, TData) block.

Log entry of the LoggingFSM - can be obtained by calling [!:GetLog]

Default FSMBaseReason if calling Stop().

Reason why this FSMTState, TData is shutting down

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

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

Used in the event of a timeout between transitions

Class representing the state of the FSMTState, TData within the OnTermination block.

Send this to an FSMBaseSubscribeTransitionCallBack to request first the FSMBaseUnsubscribeTransitionCallBack followed by a series of FSMBaseTransitionTS updates. Cancel the subscription using FSMBaseCurrentStateTS.

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

Unsubscribe from FSMBaseSubscribeTransitionCallBack notifications which were initialized by sending the corresponding FSMBaseTransitionTS.

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

Returns a Task that will be completed with success when existing messages of the target actor have been processed and the actor has been terminated. Useful when you need to wait for termination or compose ordered termination of several actors, which should only be done outside of the ActorSystem as blocking inside ActorBase is discouraged. If the target actor isn't terminated within the timeout the Task is complted with failure. If you want to invoke specialized stopping logic on your target actor instead of PoisonPill, you can pass your stop command as a parameter:

Class GuardianActor.

IllegalActorNameException is thrown when an Actor with an invalid name is deployed our bound.

IllegalActorStateException 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.

An InvalidActorNameException is thrown when the actor name is invalid

InvalidMessageException is thrown when an invalid message is sent to an Actor. Currently only null is an invalid message.

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(ActorRef) which causes the actor to stop without processing any more messages.

Class LocalActorRefProvider. This class cannot be inherited.

Class LoggerInitializationException is thrown to indicate that there was a problem initializing a logger.

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

Class OneForOneStrategy. This class cannot be inherited.

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

Sending a PoisonPill to an 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(ActorRef) which causes the actor to stop without processing any more messages.

A PostRestartException is thrown when constructor or postRestart() method fails during a restart attempt.

[!:PostRestartException.Actor]: actor is the actor whose constructor or postRestart() hook failed.

[!:PostRestartException.Cause]: cause is the exception thrown by that actor within preRestart()

OriginalCause: originalCause is the exception which caused the restart in the first place

Class PreRestartException.

Props is a configuration object using in creating an [[Actor]]; it is immutable, so it is thread-safe and fully shareable. Examples on C# API:

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.

Class RootActorPath.

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

Class Scheduler.

Class SelectChildName.

Class SelectChildPattern.

Class SelectionPathElement.

Class SelectParent.

Settings are 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"

Static factor used for creating Stash instances

Is thrown when the size of the Stash exceeds the capacity of the stash

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.

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

Indicates the success of some operation which has been performed

Base class for supervision strategies

Class TypedActor.

Class UntypedActor.

An UntypedActor with bounded Stash capabilities

An UntypedActor with Unbounded Stash capabilities

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

Interface ActorRefFactory

All ActorRefs have a scope which describes where they live. Since it is often necessary to distinguish between local and non-local references, this is the only method provided on the scope. INTERNAL

Interface used on Actors that have an explicit requirement for a logger

Plugin interface used to define

Marker interface for adding stash support

Marker interface used to identify an object as ActorSystem extension

Non-generic version of interface, mostly to avoid issues with generic casting

Marker interface used to distinguish a unqiue ActorSystem extensions

Interface IHandle

Contains things needed by the framework

Interface ILogReceive

Inboxable 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.

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.

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

Interface IUntypedActorContext

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

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

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

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 [!:IsSt] features here; it is not improbable that cluster actor refs will have the same behavior. INTERNAL

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

Copy
public IStash Stash { get; set; }

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

Copy
public IStash Stash { get; set; }

Delegate Receive

Delegate UntypedReceive

Enum Directive for supervisor actions