Orleans.Runtime Namespace

A placement strategy which attempts to achieve approximately even load based upon the number of recently-active grains on each server.

Functionality for converting ActivationId instances to and from their JSON representation.

Represents a request to an IAsyncEnumerable<T>-returning method.

A helper utility class that allows to control the rate of generation of asynchronous activities. Maintains a pipeline of asynchronous operations up to a given maximal capacity and blocks the calling thread if the pipeline gets too deep before enqueued operations are not finished. Effectively adds a back-pressure to the caller. This is mainly usefull for stress-testing grains under controlled load and should never be used from within a grain code!

Gets a GrainInterfaceType from attributes implementing IGrainInterfaceTypeProviderAttribute.

Indicates that a client is not longer reachable.

Represents an update to the cluster manifest.

Represents a cluster member.

Represents a snapshot of cluster membership.

Represents a cluster membership snapshot and changes from a previous snapshot.

Manages log sinks

Signifies that a silo has detected a deadlock / loop in a call graph.

The default IGrainActivator implementation.

Indicates that an enumeration was aborted.

Signifies that a gateway silo is currently in overloaded / load shedding state and is unable to currently accept this message being sent.

Represents an entry in a IGrainDirectory

Represents a directive to update an invalid, cached GrainAddress to a valid GrainAddress.

Constructs instances of a grain class using constructor dependency injection.

The central point for creating grain contexts.

Extensions for IGrainContext.

Signifies that an attempt was made to invoke a grain extension method on a grain where that extension was not installed.

Functionality for converting a GrainId to and from a JSON string.

Extensions for GrainId keys.

When applied to a grain interface, specifies the GrainInterfaceType.

Stages of a grains lifecycle. TODO: Add more later, see ActivationInitializationStage Full grain lifecycle, including register, state setup, and stream cleanup should all eventually be triggered by the grain lifecycle.

This is the base class for all grain references.

Indicates that a GrainReference was not bound to the runtime before being used.

Properties common to GrainReference instances with the same GrainType and GrainInterfaceType.

Base class for implementing a grain-like partitioned service with per silo instances of it automatically instantiated and started by silo runtime

Prefixes and corresponding helper methods for GrainType.

Functionality which is shared between all instances of a grain type.

Resolves components which are common to all instances of a given grain type.

A unique identifier based on a Guid.

Places activations on compatible silos by hashing the grain identifier using a stable hash and selecting a silo from a sorted set using a modulo operation.

Functionality for serializing and deserializing IdSpan instances.

Represents a service which is identified by a key.

Represents a service which is identified by a key.

Represents a collection of services with a given key type.

Extension method for IServiceProvider for working with IKeyedServiceCollection<TKey,TService>.

Extensions for working with keyed services.

Represents a singleton service which is identified by a key.

Represents a singleton keyed service.

Extensions for ILifecycleParticipant<TLifecycleObservable>.

Signifies that a grain is in an overloaded state where some runtime limit setting is currently being exceeded, and so that grain is unable to currently accept the message being sent.

Formats values for logging purposes.

Interface of Orleans runtime for logging services.

Logging Utility

Manages log sinks

Functionality for converting MembershipVersion instances to and from JSON.

Helper class used to invoke OnDeserialized(DeserializationContext) on objects which implement IOnDeserialized, immediately after deserialization.

Represents a configuration exception.

An exception class used by the Orleans runtime for reporting errors.

Indicates a lifecycle was canceled, either by request or due to observer error.

Extension methods which preserves legacy orleans log methods style

Indicates that an Orleans message was rejected.

Specifies options for the IPersistentState<TState> constructor argument which it is applied to.

Creates IPersistentState<TState> instances for grains.

The base type for all placement strategies.

The prefer local placement strategy indicates that a grain should always be placed on the local host if the grain is not already active elsewhere in the cluster and the local host is compatible with it.

The random placement strategy specifies that new activations of a grain should be placed on a random, compatible server.

Utility class for creating IRingRange values.

Exception related to Orleans Reminder functions or Reminder service.

Base class for requests for methods which return ValueTask.

Base class for requests for methods which return ValueTask<TResult>.

Base type used for method requests.

This class holds information regarding the request currently being processed. It is explicitly intended to be available to application code.

Extensions for working with RequestContext.

A placement strategy which attempts to optimize resource distribution across the cluster.

Orleans silo.

Data class encapsulating the details of silo addresses.

Functionality for converting SiloAddress instances to and from their JSON representation.

Decorator over lifecycle subject for silo. Adds some logging and monitoring

The silo role placement strategy specifies that a grain should be placed on a compatible silo which has the role specified by the strategy's placement attribute.

Snapshot of current runtime statistics for a silo

Extensions for SiloStatus.

Signifies that an request was canceled due to target silo unavailability.

Simple snapshot of current statistics for a given grain type on a given silo.

Base class for various system services, such as grain directory, reminder service, etc. Made public for GrainService to inherit from it. Can be turned to internal after a refactoring that would remove the inheritance relation.

Extensions for SystemTarget.

The placement strategy used by system targets.

Base class for requests for methods which return ValueTask.

Base class for requests for methods which return Task<TResult>.

Support backwards compatability with old TraceManager for logger managament api

Options for formatting type names.

The Utils class contains a variety of utility methods for use in application and grain code.

Base class for requests for void-returning methods.

An exception class used by the Orleans runtime for reporting errors.

Uniquely identifies a grain activation.

Represents a GrainInterfaceType that is parameterized using type parameters.

Represents a GrainType that is parameterized using type parameters.

Identifies a grain.

Uniquely identifies a grain interface.

Represents the type of a grain.

Primitive type for identities, representing a sequence of bytes.

Represents the result of probing a node via an intermediary node.

Identifies the version of a cluster membership configuration.

Identifies a Stream within a provider

Identifies a system target.

The status of a tick when the tick is delivered to the registrar grain. In case of failures, it may happen that a tick is not delivered on time. The app can notice such missed ticks as follows. Upon receiving a tick, the app can calculate the theoretical number of ticks since start of the reminder as: curCount = (Now - FirstTickTime) / Period The app can keep track of it as 'count'. Upon receiving a tick, the number of missed ticks = curCount - count - 1 Thereafter, the app can set count = curCount

Manages the set of recently active IGrainContext instances.

Represents an activation from the perspective of IActivationWorkingSet.

An IActivationWorkingSet observer.

Marker interface for addressable endpoints, such as grains, observers, and other system-internal addressable endpoints

Grain extension interface for grains which return IAsyncEnumerable<T> from grain methods.

Interface for requests to a IAsyncEnumerable<T>-returning methods.

Responsible for mapping a facet metadata to a cachable factory.

A small set of per-Orleans-client important key performance metrics.

An interface used to consume log entries, when a Close function is also supported.

Provides access to the cluster manifest.

Functionality for querying and interacting with cluster membership.

Configures the provided grain context.

Provides a IConfigureGrainContext instance for the provided grain type.

Configures shared components which are common for all instances of a given grain type.

A detailed statistic counter. Usually a low level performance statistic used in troubleshooting scenarios.

Records the state of a grain activation which is in the process of being dehydrated for migration to another location.

Interface for controlling how fatal errors (such as a silo being declared defunct) are handled.

An interface used to consume log entries, when a Flush function is also supported.

The context associated with the current grain activation.

Creates a grain instance for a given grain context.

Represents a grain from the perspective of the runtime.

Provides access to the currently executing grain context.

Creates a grain context for the given grain address.

Provides a IGrainContextActivator for a specified grain type.

Marker interface for grain extensions, used by internal runtime extension endpoints.

Functionality for accessing or installing an extension on a grain.

Gets a GrainInterfaceType for an interface.

An Attribute which implements this specifies the GrainInterfaceType of the type which it is attached to.

The observable grain lifecycle.

Runtime logic for GrainReferences to be usable. This service is not meant to be used directly by user code.

Handle for a persistent Reminder.

The gateway of the Grain to the Orleans runtime. The Grain should only interact with the runtime through this interface.

Functionality for interacting with grain services.

Interface for services which can be probed for health status.

Interface for health check participants

Represents a service which is identified by a key.

Collection of services that can be disambiguated by key

Details of the local silo.

An interface used to consume log entries.

Interface for system management functions of silos, exposed as a grain for receiving remote requests / commands.

Authoritative source for cluster membership.

Provides access to grain state with functionality to save, clear, and refresh the state.

Configuration for persistent state.

Factory for constructing IPersistentState<TState> instances for a grain.

A utility interface that allows to control the rate of generation of asynchronous activities.

Contains the state of a grain activation which is in the process of being rehydrated after moving from another location.

Represents a request to invoke a method on a grain.

Represents a range or set of ranges around a virtual ring where points along the ring are identified using UInt32 values.

The observable silo lifecycle.

Observable silo lifecycle and observer.

A small set of per-silo important key performance metrics

Interface for types which listen to silo status change notifications.

Authoritative local, per-silo source for information about the status of other silos.

Represents a single, contiguous range round a virtual ring where points along the ring are identified using UInt32 values.

Defines an action to be taken after silo startup.

Marker interface for all Telemetry Consumers

Represents an object used for producing telemetry

Provides methods for resolving a Type from a string.

Functionality to schedule tasks on a grain.

Identifies enumeration results.

Possible statuses of a grain service

The ILogConsumer distinguishes between four categories of logs:

Severity levels for log messages.

Silo Types.

Possible statuses of a silo.

Type id values encoded into UniqueKeys