Search Results for

    Show / Hide Table of Contents

    Namespace Akka.Actor

    Classes

    ActorBase

    Class ActorBase.

    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.

    ActorPath

    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

    TBD

    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

    TBD

    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.

    IWithTimers

    Marker interface for adding Timers support

    IWithUnboundedStash

    The IWithUnboundedStash interface is a version of IActorStash that enforces an unbounded stash for you actor.

    IWithUnrestrictedStash

    A version of IActorStash that does not enforce any mailbox type. The proper mailbox has to be configured manually, and the mailbox should extend the IDequeBasedMessageQueueSemantics marker interface.

    IWrappedMessage

    Message envelopes may implement this trait for better logging, such as logging of message class name of the wrapped message instead of the envelope class name.

    Enums

    Directive

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

    Delegates

    FSM<TState, TData>.StateFunction

    Delegate describing this state's response to input

    FSM<TState, TData>.TransitionHandler

    Handler which is called upon each state transition

    Receive

    Delegate Receive

    UntypedReceive

    Delegate UntypedReceive

    In This Article
    Back to top
    Contribute
    • Project Chat
    • Discussion Forum
    • Source Code
    Support
    • Akka.NET Support Plans
    • Akka.NET Observability Tools
    • Akka.NET Training & Consulting
    Maintained By
    • Petabridge - The Akka.NET Company
    • Learn Akka.NET