Class ActorBase.

TBD

Response to the Identify message, get identity by Sender

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

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.

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

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.

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

TBD

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

Base actor producer pipeline plugin class.

Base generic actor producer pipeline plugin class.

TBD

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

An extension method class for working with ActorRefs

TBD

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.

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.

TBD

TBD

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.

Class ActorSelectionMessage.

TBD

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`): Where no name is given explicitly, one will be automatically generated. Important Notice: This class is not meant to be extended by user code.

This class contains extension methods used for resolving ActorSystem extensions.

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.

TBD

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

Class AllForOneStrategy. This class cannot be inherited. The result of this strategy is applied to the failed child and all its siblings.

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

A ICancelable that is already canceled.

This exception is thrown when an Ask operation times out.

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

TBD

Class ChildActorPath.

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

Used to register the CoordinatedShutdown extension with a given ActorSystem.

TBD

Class DeadLetterActorRef.

INTERNAL API Mailbox for dead letters.

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.

TBD

Obsolete. Use HashedWheelTimerScheduler instead.

TBD

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

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

TBD

Used to configure and deploy actors.

TBD

TBD

TBD

Class EventStreamActor.

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

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

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.

TBD

TBD

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

TBD

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

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

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

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

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.

TBD

INTERNAL API. Abstract implementation of IInternalActorRef.

This exception is thrown when the actor name is invalid.

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

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.

TBD

Class LocalActorRefProvider. This class cannot be inherited.

TBD

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

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

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

INTERNAL API. Barebones IActorRef with no backing actor or ActorCell.

TBD

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

A surrogate for serializing Nobody.

Class OneForOneStrategy. This class cannot be inherited. The result of this strategy is applied only to the failing child

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

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

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

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

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

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

TBD

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.

Extractor class for so-called "relative actor paths" - as in "relative URI", not "relative to some other actors." Examples: * "grand/child" * "/user/hello/world"

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

TBD

Class RootActorPath.

INTERNAL API. Used by GuardianActor

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

TBD

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.

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

TBD

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

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

This exception 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

TBD

Base class for supervision strategies

TBD

System guardian. Root actor for all actors under the /system path.

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.

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

Class TypedActor.

INTERNAL API

Class UntypedActor.

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

A scheduler able of scheduling actions

TBD

Plugin interface used to define

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.

Interface IActorRefFactory

TBD

INTERNAL API 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.

Marker interface for adding stash support

TBD

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

Signifies something that can be canceled

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

TBD

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

TBD

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

This interface is used to distinguish unique ActorSystem extensions.

This interface is used to distinguish unique ActorSystem extensions.

Interface IHandle

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.

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.

Contains things needed by the framework

INTERNAL API. Used by built-in IActorRef implementations for handling internal operations that are not exposed directly to end-users.

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

Interface ILogReceive

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

TBD

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

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.

TBD

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

A scheduler that's able to schedule sending messages.

TBD

Interface IUntypedActorContext

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

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

Delegate describing this state's response to input

Handler which is called upon each state transition

Delegate Receive

Delegate UntypedReceive

Enum Directive for supervisor actions