Click or drag to resize
Akka.NETAkka.Actor Namespace
The Akka.Actor namespace contains classes used to create and manage actors including lifecycle, message receiving and handling.
Public classActorBase
Class ActorBase.
Public classActorCell
Public classActorIdentity
Response to the Identify message, get identity by Sender
Public classActorInitializationException
This exception is thrown when the initialization logic for an Actor fails.
Public classActorInterruptedException
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.
Public classActorKilledException
This exception is thrown when a Kill message has been sent to an Actor. DefaultDecider will by default stop the actor.
Public classActorNotFoundException
This exception is thrown when an Actor can not be found.
Public classActorPath
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.
Public classActorPathSurrogate
This class represents a surrogate of an ActorPath. Its main use is to help during the serialization process.
Public classActorProducerPipeline
Public classActorProducerPipelineResolver
Class used to resolving actor producer pipelines depending on actor type.
Public classActorProducerPluginBase
Base actor producer pipeline plugin class.
Public classActorProducerPluginBaseTActor
Base generic actor producer pipeline plugin class.
Public classActorRefBase
Public classActorRefBaseSurrogate
This class represents a surrogate of a ActorRefBase router. Its main use is to help during the serialization process.
Public classActorRefExtensions
An extension method class for working with ActorRefs
Public classActorRefFactoryExtensions
Public classActorRefFactoryShared
This class contains implementations originally found in Akka´s trait ActorRefFactory in ActorRefProvider.scala IActorRefFactory corresponds to that trait, but since it is an interface it cannot contain any code, hence this class.
Public classActorRefImplicitSenderExtensions
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.
Public classActorRefs
Public classActorRefWithCell
Public classActorSelection
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.
Public classActorSelectionMessage
Class ActorSelectionMessage.
Public classActorStashPlugin
Public classActorSystem
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.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.
Public classActorSystemWithExtensions
This class contains extension methods used for resolving ActorSystem extensions.
Public classAddress
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.
Public classAddressAddressSurrogate
Public classAkkaException
This exception provides the base for all Akka.NET specific exceptions within the system.
Public classAllForOneStrategy
Class AllForOneStrategy. This class cannot be inherited. The result of this strategy is applied to the failed child and all its siblings.
Public classAllForOneStrategyAllForOneStrategySurrogate
This class represents a surrogate of a AllForOneStrategy router. Its main use is to help during the serialization process.
Public classAlreadyCanceledCancelable
A ICancelable that is already canceled.
Public classAskTimeoutException
This exception is thrown when an Ask operation times out.
Public classCancelable
A ICancelable that wraps a CancellationTokenSource. When canceling this instance the underlying CancellationTokenSource is canceled as well.
Public classCancelableExtensions
Public classChildActorPath
Class ChildActorPath.
Public classCoordinatedShutdown
An ActorSystem extension used to help coordinate and sequence shutdown activities during graceful termination of actor systems, plugins, and so forth.
Public classCoordinatedShutdownExtension
Used to register the CoordinatedShutdown extension with a given ActorSystem.
Public classDateTimeOffsetNowTimeProvider
Public classDeadLetterActorRef
Class DeadLetterActorRef.
Public classDeadLetterMailbox
INTERNAL API Mailbox for dead letters.
Public classDeathPactException
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.
Public classDecider
Public classDedicatedThreadScheduler Obsolete.
Obsolete. Use HashedWheelTimerScheduler instead.
Public classDefaultSupervisorStrategy
Public classDeploy
This class represents a configuration object used in the deployment of an actor.
Public classDeployDeploySurrogate
This class represents a surrogate of a Deploy configuration object. Its main use is to help during the serialization process.
Public classDeployableDecider
Public classDeployer
Used to configure and deploy actors.
Public classDeprecatedSchedulerExtensions Obsolete.
Public classDirectiveExtensions
Public classEmptyLocalActorRef
Public classEventStreamActor
Class EventStreamActor.
Public classExtendedActorSystem
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!

Public classExtensionIdProviderT
This class represents the base provider implementation for creating, registering and retrieving extensions within an ActorSystem.
Public classFailure
Represents a single failure.
Public classFailures
Collection of failures, used to keep track of how many times a given actor have failed.
Public classFSMTState, TData
Finite state machine (FSM) actor.
Public classFSMTState, TDataTransformHelper
Public classFSMBase
Public classFSMBaseCurrentStateTS
Public classFSMBaseEventTD
Public classFSMBaseFailure
Public classFSMBaseLogEntryTS, TD
Log entry of the ILoggingFSM - can be obtained by calling [!:GetLog]
Public classFSMBaseNormal
Public classFSMBaseReason
Public classFSMBaseShutdown
Reason given when someone as calling Stop from outside; also applies to ActorSystem supervision directive.
Public classFSMBaseStateTS, TD
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.
Public classFSMBaseStateTimeout
Used in the event of a timeout between transitions
Public classFSMBaseStopEventTS, TD
Public classFSMBaseSubscribeTransitionCallBack
Public classFSMBaseTransitionTS
Message type which is used to communicate transitions between states to all subscribed listeners (use FSMBaseSubscribeTransitionCallBack)
Public classFSMBaseUnsubscribeTransitionCallBack
Public classFutureActorRef
Public classFutures
Extension method class designed to create Ask support for non-ActorRef objects such as ActorSelection.
Public classGracefulStopSupport
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.
IMPORTANT: the actor being terminated and its supervisor being informed of the availability of the deceased actor's name are two distinct operations, which do not obey any reliable ordering.
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:
GracefulStop(someChild, timeout, MyStopGracefullyMessage).ContinueWith(r => {
    // Do something after someChild starts being stopped.
Public classGuardianActor
Class GuardianActor.
Public classHashedWheelTimerScheduler
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: Presentation:
Public classIdentify
Request to an ICanTell to get back the identity of the underlying actors.
Public classIllegalActorNameException
This exception is thrown when an Actor with an invalid name is deployed.
Public classIllegalActorStateException
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.
Public classInbox
Public classInternalActorRefBase
INTERNAL API. Abstract implementation of IInternalActorRef.
Public classInvalidActorNameException
This exception is thrown when the actor name is invalid.
Public classInvalidMessageException
This exception is thrown when an invalid message is sent to an Actor.
Note Note
Currently only null is an invalid message.
Public classKill
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.

Public classLocalActorRef
Public classLocalActorRefProvider
Class LocalActorRefProvider. This class cannot be inherited.
Public classLocalOnlyDecider
Public classLocalScope
This class represents a binding of an actor deployment to a local system.
Public classLocalScopeLocalScopeSurrogate
This class represents a surrogate of a LocalScope binding. Its main use is to help during the serialization process.
Public classLoggerInitializationException
This exception is thrown when there was a problem initializing a logger.
Public classMinimalActorRef
INTERNAL API. Barebones IActorRef with no backing actor or ActorCell.
Public classNameAndUid
Public classNobody
This is an internal look-up failure token, not useful for anything else.
Public classNobodyNobodySurrogate
A surrogate for serializing Nobody.
Public classOneForOneStrategy
Class OneForOneStrategy. This class cannot be inherited. The result of this strategy is applied only to the failing child
Public classOneForOneStrategyOneForOneStrategySurrogate
This class represents a surrogate of a OneForOneStrategy router. Its main use is to help during the serialization process.
Public classPipeToSupport
Creates the PipeTo pattern for automatically sending the results of completed tasks into the inbox of a designated Actor
Public classPoisonPill
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.

Public classPostRestartException
This exception is thrown when the Actor constructor or PostRestart(Exception) method fails during a restart attempt.
Public classPreRestartException
This exception is thrown when the PreRestart(Exception, Object) method fails during a restart attempt.
Note 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.
Public classCode exampleProps
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);
Public classPropsPropsSurrogate
This class represents a surrogate of a Props configuration object. Its main use is to help during the serialization process.
Public classReceiveActor
Public classReceiveTimeout
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.
Public classRelativeActorPath
Extractor class for so-called "relative actor paths" - as in "relative URI", not "relative to some other actors." Examples: * "grand/child" * "/user/hello/world"
Public classRemoteScope
This class represents a binding of an actor deployment to a remote system. Actors in this scope are deployed to a specified Address.
Public classRepointableActorRef
Public classRootActorPath
Class RootActorPath.
Public classRootGuardianActorRef
INTERNAL API. Used by GuardianActor
Public classRootGuardianSupervisor
Top-level anchor for the supervision hierarchy of this actor system. Note: This class is called theOneWhoWalksTheBubblesOfSpaceTime in Akka
Public classScheduledWork
Public classSchedulerBase
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.
Public classSchedulerException
An AkkaException that is thrown by the [!:IScheduler.Schedule*] methods when scheduling is not possible, e.g. after shutting down the IScheduler.
Public classSchedulerExtensions
Public classScope
This class provides base functionality when defining a system binding (e.g. local/remote/cluster) used during actor deployment.
Public classSelectChildName
Class SelectChildName.
Public classSelectChildPattern
Class SelectChildPattern.
Public classSelectionPathElement
Class SelectionPathElement.
Public classSelectParent
Class SelectParent.
Public classSettings
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"
Public classStashFactory
Static factor used for creating Stash instances
Public classStashOverflowException
This exception is thrown when the size of the Stash exceeds the capacity of the stash.
Public classStatus
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.
Public classStatusFailure
Indicates the failure of some operation that was requested and includes an Exception describing the underlying cause of the problem.
Public classStatusSuccess
Indicates the success of some operation which has been performed
Public classStoppingSupervisorStrategy
Public classSupervisorStrategy
Base class for supervision strategies
Public classSupervisorStrategyConfigurator
Public classSystemGuardianActor
System guardian. Root actor for all actors under the /system path.
Public classTerminated
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.
Public classTerminatedProps
This class represents a specialized Props used when the actor has been terminated.
Public classTypedActor
Class TypedActor.
Public classUnstartedCell
Public classUntypedActor
Class UntypedActor.
Public structureEnvelope
Envelope class, represents a message and the sender of the message.
Public interfaceIActionScheduler
A scheduler able of scheduling actions
Public interfaceIActorContext
Public interfaceIActorProducerPlugin
Plugin interface used to define
Public interfaceIActorRef
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.
Public interfaceIActorRefFactory
Interface IActorRefFactory
Public interfaceIActorRefProvider
Public interfaceIActorRefScope
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.
Public interfaceIActorStash
Marker interface for adding stash support
Public interfaceIAdvancedScheduler
Public interfaceIAutoReceivedMessage
Marker trait to show which Messages are automatically handled by Akka.NET
Public interfaceICancelable
Signifies something that can be canceled
Public interfaceICanTell
A shared interface for both IActorRef and ActorSelection, both of which can be sent messages via the Tell(Object, IActorRef) command.
Public interfaceICanWatch
Public interfaceICell
Note! Part of internal API. Breaking changes may occur without notice. Use at own risk.
Public interfaceIDateTimeOffsetNowTimeProvider
Marks that an ITimeProvider uses UtcNow, i.e. system time, to provide Now.
Public interfaceIDecider
Public interfaceIExtension
This interface is used to mark an object as an ActorSystem extension.
Public interfaceIExtensionId
This interface is used to distinguish unique ActorSystem extensions.
Public interfaceIExtensionIdT
This interface is used to distinguish unique ActorSystem extensions.
Public interfaceIHandleTMessage
Interface IHandle
Public interfaceIInboxable
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.
Public interfaceIIndirectActorProducer
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 interfaceIInternalActor
Contains things needed by the framework
Public interfaceIInternalActorRef
INTERNAL API. Used by built-in IActorRef implementations for handling internal operations that are not exposed directly to end-users.
Public interfaceILoggingFSM
Public interfaceILogReceive
Interface ILogReceive
Public interfaceINoSerializationVerificationNeeded
Marker Interface INoSerializationVerificationNeeded, this interface prevents implementing message types from being serialized if configuration setting '' is "on"
Public interfaceINotInfluenceReceiveTimeout
Public interfaceIPossiblyHarmful
Marker interface to indicate that a message might be potentially harmful; this is used to block messages coming in over remoting.
Public interfaceIRepointableRef
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.
Public interfaceIScheduler
Public interfaceIStash
Public interface used to expose stash capabilities to user-level actors
Public interfaceITellScheduler
A scheduler that's able to schedule sending messages.
Public interfaceITimeProvider
Public interfaceIUntypedActorContext
Interface IUntypedActorContext
Public interfaceIWithBoundedStash Obsolete.
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; }
Public interfaceIWithUnboundedStash
Lets the StashFactory know that this Actor needs stash support with unrestricted storage capacity. You need to add the property:
public IStash Stash { get; set; }
Public enumerationDirective
Enum Directive for supervisor actions