Orleans.Runtime Namespace

Classes

ActivationCountBasedPlacement

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

ActivationIdConverter

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

AsyncEnumerableExtensions
AsyncEnumerableRequest<T>

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

AsyncPipeline

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!

AttributeGrainInterfaceTypeProvider

Gets a GrainInterfaceType from attributes implementing IGrainInterfaceTypeProviderAttribute.

ClientInstruments
ClientNotAvailableException

Indicates that a client is not longer reachable.

ClusterManifestUpdate

Represents an update to the cluster manifest.

ClusterMember

Represents a cluster member.

ClusterMembershipSnapshot

Represents a snapshot of cluster membership.

ClusterMembershipUpdate

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

ConsoleTelemetryConsumer
CrashUtils

Manages log sinks

DeadlockException

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

DefaultGrainActivator

The default IGrainActivator implementation.

DetailedGrainStatistic
EnumerationAbortedException

Indicates that an enumeration was aborted.

FileTelemetryConsumer
FloatValueStatistic
GatewayTooBusyException

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

GrainAddress

Represents an entry in a IGrainDirectory

GrainAddressCacheUpdate

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

GrainConstructorArgumentFactory

Constructs instances of a grain class using constructor dependency injection.

GrainContextActivator

The central point for creating grain contexts.

GrainContextExtensions

Extensions for IGrainContext.

GrainExtensionNotInstalledException

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

GrainIdJsonConverter

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

GrainIdKeyExtensions

Extensions for GrainId keys.

GrainInterfaceTypeAttribute

When applied to a grain interface, specifies the GrainInterfaceType.

GrainLifecycleStage

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.

GrainReference

This is the base class for all grain references.

GrainReferenceExtensions
GrainReferenceNotBoundException

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

GrainReferenceShared

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

GrainService

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

GrainTypePrefix

Prefixes and corresponding helper methods for GrainType.

GrainTypeSharedContext

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

GrainTypeSharedContextResolver

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

GuidId

A unique identifier based on a Guid.

HashBasedPlacement

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.

IdSpanCodec

Functionality for serializing and deserializing IdSpan instances.

Instruments
KeyedService<TKey,TService>

Represents a service which is identified by a key.

KeyedService<TKey,TService,TInstance>

Represents a service which is identified by a key.

KeyedServiceCollection<TKey,TService>

Represents a collection of services with a given key type.

KeyedServiceCollectionExtensions

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

KeyedServiceExtensions

Extensions for working with keyed services.

KeyedSingletonService<TKey,TService>

Represents a singleton service which is identified by a key.

KeyedSingletonService<TKey,TService,TInstance>

Represents a singleton keyed service.

LegacyGrainId
LifecycleParticipantExtensions

Extensions for ILifecycleParticipant<TLifecycleObservable>.

LimitExceededException

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.

LogFormatter

Formats values for logging purposes.

Logger

Interface of Orleans runtime for logging services.

LoggerExtensionMethods
LoggerExtensions
LoggingUtils

Logging Utility

LogManager

Manages log sinks

MembershipVersionConverter

Functionality for converting MembershipVersion instances to and from JSON.

Metric
OnDeserializedCallbacks

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

OrleansConfigurationException

Represents a configuration exception.

OrleansException

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

OrleansLifecycleCanceledException

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

OrleansLoggerExtension

Extension methods which preserves legacy orleans log methods style

OrleansMessageRejectionException

Indicates that an Orleans message was rejected.

PersistentStateAttribute

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

PersistentStateFactory

Creates IPersistentState<TState> instances for grains.

PlacementStrategy

The base type for all placement strategies.

PreferLocalPlacement

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.

RandomPlacement

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

RangeFactory

Utility class for creating IRingRange values.

ReminderException

Exception related to Orleans Reminder functions or Reminder service.

Request

Base class for requests for methods which return ValueTask.

Request<TResult>

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

RequestBase

Base type used for method requests.

RequestContext

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

RequestContextExtensions

Extensions for working with RequestContext.

ResourceOptimizedPlacement

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

Silo

Orleans silo.

SiloAddress

Data class encapsulating the details of silo addresses.

SiloAddressConverter

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

SiloLifecycleSubject

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

SiloRoleBasedPlacement

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.

SiloRuntimeMetricsListener
SiloRuntimeStatistics

Snapshot of current runtime statistics for a silo

SiloStatusExtensions

Extensions for SiloStatus.

SiloUnavailableException

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

SiloUnobservedExceptionsHandlerServiceProviderExtensions
SimpleGrainStatistic

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

StatisticName
StatisticNameFormat
StatisticNames
SystemTarget

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.

SystemTargetExtensions

Extensions for SystemTarget.

SystemTargetPlacementStrategy

The placement strategy used by system targets.

TaskRequest

Base class for requests for methods which return ValueTask.

TaskRequest<TResult>

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

TelemetryManager
TraceLogger

Support backwards compatability with old TraceManager for logger managament api

TraceTelemetryConsumer
TypeFormattingOptions

Options for formatting type names.

UniqueKey
Utils

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

VoidRequest

Base class for requests for void-returning methods.

WrappedException

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

Structs

ActivationId

Uniquely identifies a grain activation.

GenericGrainInterfaceType

Represents a GrainInterfaceType that is parameterized using type parameters.

GenericGrainType

Represents a GrainType that is parameterized using type parameters.

GrainId

Identifies a grain.

GrainInterfaceType

Uniquely identifies a grain interface.

GrainType

Represents the type of a grain.

IdSpan

Primitive type for identities, representing a sequence of bytes.

IndirectProbeResponse

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

MembershipVersion

Identifies the version of a cluster membership configuration.

QualifiedStreamId
RequestContext.ReentrancySection
StreamId

Identifies a Stream within a provider

SystemTargetGrainId

Identifies a system target.

TickStatus

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

Interfaces

IActivationWorkingSet

Manages the set of recently active IGrainContext instances.

IActivationWorkingSetMember

Represents an activation from the perspective of IActivationWorkingSet.

IActivationWorkingSetObserver

An IActivationWorkingSet observer.

IAddressable

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

IAsyncEnumerableGrainExtension

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

IAsyncEnumerableRequest<T>

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

IAttributeToFactoryMapper<TMetadata>

Responsible for mapping a facet metadata to a cachable factory.

IClientMetricsDataPublisher
IClientPerformanceMetrics

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

ICloseableLogConsumer

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

IClusterManifestProvider

Provides access to the cluster manifest.

IClusterMembershipService

Functionality for querying and interacting with cluster membership.

IConfigurableClientMetricsDataPublisher
IConfigurableSiloMetricsDataPublisher
IConfigurableStatisticsPublisher
IConfigureGrainContext

Configures the provided grain context.

IConfigureGrainContextProvider

Provides a IConfigureGrainContext instance for the provided grain type.

IConfigureGrainTypeComponents

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

ICorePerformanceMetrics
ICounter

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

IDehydrationContext

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

IDependencyTelemetryConsumer
IEventTelemetryConsumer
IExceptionTelemetryConsumer
IFatalErrorHandler

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

IFlushableLogConsumer

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

IGrainActivationContext

The context associated with the current grain activation.

IGrainActivator

Creates a grain instance for a given grain context.

IGrainContext

Represents a grain from the perspective of the runtime.

IGrainContextAccessor

Provides access to the currently executing grain context.

IGrainContextActivator

Creates a grain context for the given grain address.

IGrainContextActivatorProvider

Provides a IGrainContextActivator for a specified grain type.

IGrainExtension

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

IGrainExtensionBinder

Functionality for accessing or installing an extension on a grain.

IGrainInterfaceTypeProvider

Gets a GrainInterfaceType for an interface.

IGrainInterfaceTypeProviderAttribute

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

IGrainLifecycle

The observable grain lifecycle.

IGrainMigrationParticipant
IGrainReferenceConverter
IGrainReferenceRuntime

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

IGrainReminder

Handle for a persistent Reminder.

IGrainRuntime

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

IGrainServiceFactory

Functionality for interacting with grain services.

IHealthCheckable

Interface for services which can be probed for health status.

IHealthCheckParticipant

Interface for health check participants

IKeyedService<TKey,TService>

Represents a service which is identified by a key.

IKeyedServiceCollection<TKey,TService>

Collection of services that can be disambiguated by key

ILocalSiloDetails

Details of the local silo.

ILogConsumer

An interface used to consume log entries.

IManagementGrain

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

IMembershipOracle

Authoritative source for cluster membership.

IMetricTelemetryConsumer
IMultiClusterGossipData
IMultiClusterGossipService
IPersistentState<TState>

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

IPersistentStateConfiguration

Configuration for persistent state.

IPersistentStateFactory

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

IPipeline

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

IRehydrationContext

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

IRequest

Represents a request to invoke a method on a grain.

IRequestTelemetryConsumer
IRingRange

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

ISiloLifecycle

The observable silo lifecycle.

ISiloLifecycleSubject

Observable silo lifecycle and observer.

ISiloMetricsDataPublisher
ISiloPerformanceMetrics

A small set of per-silo important key performance metrics

ISiloStatusListener

Interface for types which listen to silo status change notifications.

ISiloStatusOracle

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

ISingleRange

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

IStartupTask

Defines an action to be taken after silo startup.

IStatisticsManager
IStatisticsPublisher
ITelemetryConsumer

Marker interface for all Telemetry Consumers

ITelemetryProducer

Represents an object used for producing telemetry

ITraceTelemetryConsumer
ITypeResolver

Provides methods for resolving a Type from a string.

IWorkItemScheduler

Functionality to schedule tasks on a grain.

Enums

CounterStorage
EnumerationResult

Identifies enumeration results.

GrainService.GrainServiceStatus

Possible statuses of a grain service

LoggerType

The ILogConsumer distinguishes between four categories of logs:

ValueDescription
RuntimeLogs that are written by the Orleans run-time itself. This category should not be used by application code.
GrainLogs that are written by application grains. This category should be used by code that runs as Orleans grains in a silo.
ApplicationLogs that are written by the client application. This category should be used by client-side application code.
ProviderLogs that are written by providers. This category should be used by provider code.
Severity

Severity levels for log messages.

Silo.SiloType

Silo Types.

SiloStatus

Possible statuses of a silo.

UniqueKey.Category

Type id values encoded into UniqueKeys