Proto.Actor by Proto.Actor Team

<PackageReference Include="Proto.Actor" Version="0.33.1-alpha.0.5" />

---

API Diff between 0.33.1-alpha.0.5 and 0.3.1-alpha.0.90

683 Additions 72 Removals

Proto

• public static class Actor
• public class ActorContext : IMessageInvoker, IContext, ISenderContext, IInfoContext, IReceiverContext, ISpawnerContext, IStopperContext, ISupervisor
• public abstract class ActorContextDecorator : IContext, ISenderContext, IInfoContext, IContextStore, ISystemContext, IReceiverContext, ISpawnerContext, IStopperContext
  • public void Apply(CapturedContext capturedContext)
  • public CapturedContext Capture()
  • public T Get<T>()
  • public IFuture GetFuture()
  • public virtual void Request(PID target, object message)
  • public void ReenterAfterCancellation(CancellationToken cancellationToken, Action onCancelled)
  • public void Remove<T>()
  • public virtual Task<T> RequestAsync<T>(PID target, object message, TimeSpan timeout)
  • public virtual Task<T> RequestAsync<T>(PID target, object message)
  • public void Set<T, TI>(TI obj) where TI : T
  • public virtual PID Spawn(Props props)
  • public virtual PID SpawnNamed(Props props, string name)
  • public virtual PID SpawnPrefix(Props props, string prefix)
  • public virtual PID SpawnNamed(Props props, string name, Action<IContext> callback = null)
• public sealed class ActorContextExtras : IDisposable
  • public CancellationToken CancellationToken { get; }
  • public TypeDictionary<object, ActorContextExtras> Store { get; }
  • public void Dispose()
• public class ActorLoggingContext : ActorContextDecorator
  • public ActorLoggingContext(IContext context, ILogger logger, LogLevel logLevel = 1, LogLevel infrastructureLogLevel = 6, LogLevel exceptionLogLevel = 4)
• public static class ActorLoggingContextExtensions
  • public static Props WithLoggingContextDecorator(this Props props, ILogger logger, LogLevel logLevel = 1, LogLevel infrastructureLogLevel = 6, LogLevel exceptionLogLevel = 4)
• public sealed class ActorSystem : IAsyncDisposable
  • public static readonly ActorSystem Default
  • public const string Client = "$client"
  • public const string NoHost = "nonhost"
  • public ActorSystemConfig Config { get; }
  • public ActorSystemExtensions Extensions { get; }
  • public string Id { get; }
  • public ProtoMetrics Metrics { get; }
  • public CancellationToken Shutdown { get; }
  • public Stopper Stopper { get; }
  • public ActorSystem(ActorSystemConfig config)
  • public Props ConfigureProps(Props props)
  • public Props ConfigureSystemProps(string name, Props props)
  • public ValueTask DisposeAsync()
  • public RootContext NewRoot(MessageHeader headers = null, Func<Sender, Sender>[] middleware)
  • public void SetClientAddress()
  • public Task ShutdownAsync(string reason = "")
• public class ActorSystemConfig : IEquatable<ActorSystemConfig>
  • public TimeSpan ActorRequestTimeout { get; set; }
  • public Func<Props, Props> ConfigureProps { get; set; }
  • public Func<string, Props, Props> ConfigureSystemProps { get; set; }
  • public bool DeadLetterRequestLogging { get; set; }
  • public bool DeadLetterResponseLogging { get; set; }
  • public int DeadLetterThrottleCount { get; set; }
  • public TimeSpan DeadLetterThrottleInterval { get; set; }
  • public bool DeveloperSupervisionLogging { get; set; }
  • public bool DeveloperThreadPoolStatsLogging { get; set; }
  • public Func<IActor, string> DiagnosticsSerializer { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public bool MetricsEnabled { get; set; }
  • public bool SharedFutures { get; set; }
  • public int SharedFutureSize { get; set; }
  • public TimeSpan ThreadPoolStatsTimeout { get; set; }
  • protected ActorSystemConfig(ActorSystemConfig original)
  • public ActorSystemConfig()
  • public static bool op_Equality(ActorSystemConfig left, ActorSystemConfig right)
  • public static bool op_Inequality(ActorSystemConfig left, ActorSystemConfig right)
  • public static ActorSystemConfig Setup()
  • public virtual ActorSystemConfig <Clone>$()
  • public virtual bool Equals(ActorSystemConfig other)
  • protected virtual bool PrintMembers(StringBuilder builder)
  • public ActorSystemConfig WithActorRequestTimeout(TimeSpan timeout)
  • public ActorSystemConfig WithConfigureProps(Func<Props, Props> configureProps)
  • public ActorSystemConfig WithConfigureSystemProps(Func<string, Props, Props> configureSystemProps)
  • public ActorSystemConfig WithDeadLetterRequestLogging(bool enabled)
  • public ActorSystemConfig WithDeadLetterResponseLogging(bool enabled)
  • public ActorSystemConfig WithDeadLetterThrottleCount(int deadLetterThrottleCount)
  • public ActorSystemConfig WithDeadLetterThrottleInterval(TimeSpan deadLetterThrottleInterval)
  • public ActorSystemConfig WithDeveloperSupervisionLogging(bool enabled)
  • public ActorSystemConfig WithDeveloperThreadPoolStatsLogging(bool enabled)
  • public ActorSystemConfig WithDiagnosticsSerializer(Func<IActor, string> serializer)
  • public ActorSystemConfig WithMetrics(bool enabled = true)
  • public ActorSystemConfig WithSharedFutures(int size = 5000)
  • public ActorSystemConfig WithThreadPoolStatsTimeout(TimeSpan threadPoolStatsTimeout)
• public static class ActorSystemConfigExtensions
  • public static ActorSystemConfig WithDeveloperReceiveLogging(this ActorSystemConfig self, TimeSpan receiveDeadline, LogLevel logLevel = 4)
• public abstract class AutoReceiveMessage
• public static class CancellationTokens
  • public static CancellationToken FromSeconds(int seconds)
  • public static CancellationToken WithTimeout(int ms)
  • public static CancellationToken WithTimeout(TimeSpan timeSpan)
• public class CapturedContext : IEquatable<CapturedContext>
  • public IContext Context { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public MessageEnvelope MessageEnvelope { get; set; }
  • public CapturedContext(MessageEnvelope MessageEnvelope, IContext Context)
  • protected CapturedContext(CapturedContext original)
  • public static bool op_Equality(CapturedContext left, CapturedContext right)
  • public static bool op_Inequality(CapturedContext left, CapturedContext right)
  • public virtual CapturedContext <Clone>$()
  • public void Apply()
  • public void Deconstruct(out MessageEnvelope MessageEnvelope, out IContext Context)
  • public virtual bool Equals(CapturedContext other)
  • protected virtual bool PrintMembers(StringBuilder builder)
  • public Task Receive()
• public class Continuation : SystemMessage, InfrastructureMessage
  • public IActor Actor { get; }
  • public Continuation(Func<Task> fun, object message)
  • public Continuation(Func<Task> fun, object message, IActor actor)
• public class DeadLetterEvent
  • public MessageHeader Header { get; }
  • public DeadLetterEvent(PID pid, object message, PID sender, MessageHeader header)
• public class DeadLetterException : Exception
  • public DeadLetterException(PID pid)
• public sealed class DeadLetterResponse : IMessage<DeadLetterResponse>, IMessage, IEquatable<DeadLetterResponse>, IDeepCloneable<DeadLetterResponse>, IBufferMessage
  • public const int TargetFieldNumber = 1
  • public static MessageDescriptor Descriptor { get; }
  • public static MessageParser<DeadLetterResponse> Parser { get; }
  • public PID Target { get; set; }
  • public DeadLetterResponse()
  • public DeadLetterResponse(DeadLetterResponse other)
  • public int CalculateSize()
  • public DeadLetterResponse Clone()
  • public bool Equals(DeadLetterResponse other)
  • public void MergeFrom(DeadLetterResponse other)
  • public void MergeFrom(CodedInputStream input)
  • public void WriteTo(CodedOutputStream output)
• public class EventStream : EventStream<object>
  • public int ThrottleCount { get; set; }
  • public TimeSpan ThrottleInterval { get; set; }
• public class EventStream<T>
  • public Subscription<T> Subscribe(Action<T> action, IDispatcher dispatcher = null)
  • public Subscription<T> Subscribe(Func<T, Task> action, IDispatcher dispatcher = null)
  • public Subscription<T> Subscribe<TMsg>(Action<TMsg> action, IDispatcher dispatcher = null) where TMsg : T
  • public Subscription<T> Subscribe<TMsg>(ISenderContext context, PID[] pids) where TMsg : T
  • public Subscription<T> Subscribe<TMsg>(Func<TMsg, Task> action, IDispatcher dispatcher = null) where TMsg : T
  • public EventStreamSubscription<T> Subscribe(Action<T> action, IDispatcher dispatcher = null)
  • public EventStreamSubscription<T> Subscribe(Channel<T> channel, IDispatcher dispatcher = null)
  • public EventStreamSubscription<T> Subscribe(Func<T, Task> action, IDispatcher dispatcher = null)
  • public EventStreamSubscription<T> Subscribe<TMsg>(Action<TMsg> action, IDispatcher dispatcher = null) where TMsg : T
  • public EventStreamSubscription<T> Subscribe<TMsg>(Func<TMsg, bool> predicate, Action<TMsg> action, IDispatcher dispatcher = null) where TMsg : T
  • public EventStreamSubscription<T> Subscribe<TMsg>(ISenderContext context, PID[] pids) where TMsg : T
  • public EventStreamSubscription<T> Subscribe<TMsg>(Func<TMsg, Task> action, IDispatcher dispatcher = null) where TMsg : T
  • public void Unsubscribe(Subscription<T> subscription)
  • public void Unsubscribe(EventStreamSubscription<T> subscription)
• public class EventStreamSubscription<T>
  • public Func<T, Task> Action { get; }
  • public IDispatcher Dispatcher { get; }
  • public Guid Id { get; }
  • public EventStreamSubscription(EventStream<T> eventStream, IDispatcher dispatcher, Func<T, Task> action)
  • public void Unsubscribe()
• public static class Extensions
• public interface IAutoRespond
  • object GetAutoResponse(IContext context)
• public interface IContext : ISenderContext, IInfoContext, IContextStore, ISystemContext, IReceiverContext, ISpawnerContext, IStopperContext
  • void Apply(CapturedContext capturedContext)
  • CapturedContext Capture()
  • void ReenterAfterCancellation(CancellationToken cancellationToken, Action onCancelled)
  • void Respond(object message, MessageHeader header)
• public interface IContextStore
  • T Get<T>()
  • void Remove<T>()
  • void Set<T>(T obj)
  • void Set<T, TI>(TI obj) where TI : T
• public interface IIgnoreDeadLetterLogging
• public interface IInfoContext : IContextStore, ISystemContext
  • ActorSystem System { get; }
• public interface IMessageBatch
  • IReadOnlyCollection<object> GetMessages()
• public interface InfrastructureMessage
• public interface ISenderContext : IInfoContext, IContextStore, ISystemContext
  • void Request(PID target, object message)
  • IFuture GetFuture()
  • Task<T> RequestAsync<T>(PID target, object message, TimeSpan timeout)
  • Task<T> RequestAsync<T>(PID target, object message)
• public interface ISpawnContext
• public interface ISpawnerContext : ISystemContext
  • PID Spawn(Props props)
  • PID SpawnNamed(Props props, string name)
  • PID SpawnPrefix(Props props, string prefix)
  • PID SpawnNamed(Props props, string name, Action<IContext> callback = null)
• public interface ISystemContext
  • ActorSystem System { get; }
• public static class Log
  • public static ILoggerFactory GetLoggerFactory()
• public class MessageBatch : IEquatable<MessageBatch>
  • protected virtual Type EqualityContract { get; }
  • public IReadOnlyCollection<object> Messages { get; set; }
  • public MessageBatch(IReadOnlyCollection<object> Messages)
  • protected MessageBatch(MessageBatch original)
  • public static bool op_Equality(MessageBatch left, MessageBatch right)
  • public static bool op_Inequality(MessageBatch left, MessageBatch right)
  • public virtual MessageBatch <Clone>$()
  • public void Deconstruct(out IReadOnlyCollection Messages)
  • public virtual bool Equals(MessageBatch other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class MessageEnvelope : IEquatable<MessageEnvelope>
  • protected virtual Type EqualityContract { get; }
  • protected MessageEnvelope(MessageEnvelope original)
  • public static bool op_Equality(MessageEnvelope left, MessageEnvelope right)
  • public static bool op_Inequality(MessageEnvelope left, MessageEnvelope right)
  • public static MessageEnvelope Wrap(object message, MessageHeader header)
  • public virtual MessageEnvelope <Clone>$()
  • public virtual bool Equals(MessageEnvelope other)
  • public MessageEnvelope MergeHeader(MessageHeader header)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class MessageHeader : IReadOnlyDictionary<string, string>, IEnumerable<KeyValuePair<string, string>>, IEnumerable, IReadOnlyCollection<KeyValuePair<string, string>>, IEquatable<MessageHeader>
  • protected virtual Type EqualityContract { get; }
  • public MessageHeader()
  • protected MessageHeader(MessageHeader original)
  • public static bool op_Equality(MessageHeader left, MessageHeader right)
  • public static bool op_Inequality(MessageHeader left, MessageHeader right)
  • public virtual MessageHeader <Clone>$()
  • public virtual bool Equals(MessageHeader other)
  • protected virtual bool PrintMembers(StringBuilder builder)
  • public MessageHeader With(MessageHeader header)
• public static class MetricsExtensions
  • public static Task<T> Observe<T>(this Histogram<double> histogram, Func<Task<T>> factory, KeyValuePair<string, object>[] tags)
  • public static Task Observe(this Histogram<double> histogram, Func<Task> factory, KeyValuePair<string, object>[] tags)
• public static class MurmurHash2
  • public static uint Hash(byte[] data, uint seed)
• public class NullLoggerFactory : ILoggerFactory, IDisposable
• public static class Nothing
  • public static readonly Empty Instance
• public sealed class PID : ICustomDiagnosticMessage, IMessage, IMessage<PID>, IEquatable<PID>, IDeepCloneable<PID>, IBufferMessage
  • public const int RequestIdFieldNumber = 3
  • public uint RequestId { get; set; }
  • public static PID FromAddress(string address, string id)
  • public string ToShortString()
  • public void Stop(ActorSystem system)
  • public string ToDiagnosticString()
  • public PID WithRequestId(uint requestId)
• public sealed class PoisonPill : IIgnoreDeadLetterLogging, InfrastructureMessage, IMessage<PoisonPill>, IMessage, IEquatable<PoisonPill>, IDeepCloneable<PoisonPill>, IBufferMessage
  • public static readonly PoisonPill Instance
• public class ProcessDiagnosticsRequest : SystemMessage, InfrastructureMessage, IEquatable<ProcessDiagnosticsRequest>
  • protected virtual Type EqualityContract { get; }
  • public TaskCompletionSource<string> Result { get; set; }
  • public ProcessDiagnosticsRequest(TaskCompletionSource<string> Result)
  • protected ProcessDiagnosticsRequest(ProcessDiagnosticsRequest original)
  • public static bool op_Equality(ProcessDiagnosticsRequest left, ProcessDiagnosticsRequest right)
  • public static bool op_Inequality(ProcessDiagnosticsRequest left, ProcessDiagnosticsRequest right)
  • public virtual ProcessDiagnosticsRequest <Clone>$()
  • public void Deconstruct(out TaskCompletionSource Result)
  • public virtual bool Equals(ProcessDiagnosticsRequest other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class ProcessRegistry
  • public ActorSystem System { get; }
  • public int ProcessCount { get; }
  • public IEnumerable<PID> Find(Func<string, bool> predicate)
  • public IEnumerable<PID> Find(string pattern)
  • public Process GetLocal(string id)
• public sealed delegate ProducerWithSystem : MulticastDelegate
  • public ProducerWithSystem(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ActorSystem system, AsyncCallback callback, object object)
  • public virtual IActor EndInvoke(IAsyncResult result)
  • public virtual IActor Invoke(ActorSystem system)
• public sealed delegate ProducerWithSystemAndContext : MulticastDelegate
  • public ProducerWithSystemAndContext(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ActorSystem system, IContext context, AsyncCallback callback, object object)
  • public virtual IActor EndInvoke(IAsyncResult result)
  • public virtual IActor Invoke(ActorSystem system, IContext context)
• public sealed class Props : IEquatable<Props>
  • public IList<Func<IContext, IContext>> ContextDecorator { get; }
  • public static readonly Props Empty
  • public ImmutableList<Func<IContext, IContext>> ContextDecorator { get; set; }
  • public Producer Producer { get; }
  • public IList<Func<Receiver, Receiver>> ReceiverMiddleware { get; }
  • public ProducerWithSystemAndContext Producer { get; set; }
  • public ImmutableList<Func<Receiver, Receiver>> ReceiverMiddleware { get; set; }
  • public IList<Func<Sender, Sender>> SenderMiddleware { get; }
  • public ImmutableList<Func<Sender, Sender>> SenderMiddleware { get; set; }
  • public static PID DefaultSpawner(ActorSystem system, string name, Props props, PID parent)
  • public static PID DefaultSpawner(ActorSystem system, string name, Props props, PID parent, Action<IContext> callback)
  • public static Props FromProducer(ProducerWithSystem producer)
  • public static bool op_Equality(Props left, Props right)
  • public static bool op_Inequality(Props left, Props right)
  • public Props <Clone>$()
  • public bool Equals(Props other)
  • public Props WithProducer(ProducerWithSystem producer)
  • public Props WithProducer(ProducerWithSystemAndContext producer)
• public class RestartStatistics
  • public RestartStatistics(int failureCount, DateTime? lastFailureTime)
  • public RestartStatistics(int failureCount, DateTimeOffset? lastFailureTime)
• public sealed class RootContext : IRootContext, ISpawnerContext, ISystemContext, ISenderContext, IInfoContext, IContextStore, IStopperContext, IEquatable<RootContext>
  • public static bool op_Equality(RootContext left, RootContext right)
  • public static bool op_Inequality(RootContext left, RootContext right)
  • public RootContext <Clone>$()
  • public bool Equals(RootContext other)
  • public T Get<T>()
  • public IFuture GetFuture()
  • public void Request(PID target, object message)
  • public void Remove<T>()
  • public Task<T> RequestAsync<T>(PID target, object message, TimeSpan timeout)
  • public Task<T> RequestAsync<T>(PID target, object message)
  • public PID Spawn(Props props)
  • public PID SpawnNamed(Props props, string name)
  • public PID SpawnPrefix(Props props, string prefix)
  • public void Set<T, TI>(TI obj) where TI : T
  • public PID SpawnNamed(Props props, string name, Action<IContext> callback = null)
• public abstract class RootContextDecorator : IRootContext, ISpawnerContext, ISystemContext, ISenderContext, IInfoContext, IContextStore, IStopperContext
  • public virtual T Get<T>()
  • public IFuture GetFuture()
  • public virtual void Remove<T>()
  • public virtual Task<T> RequestAsync<T>(PID target, object message, TimeSpan timeout)
  • public virtual Task<T> RequestAsync<T>(PID target, object message)
  • public virtual PID Spawn(Props props)
  • public virtual PID SpawnNamed(Props props, string name)
  • public virtual PID SpawnPrefix(Props props, string prefix)
  • public virtual void Set<T, TI>(TI obj) where TI : T
  • public virtual PID SpawnNamed(Props props, string name, Action<IContext> callback = null)
• public static class SafeTask
  • public static Task Run(Func<Task> body, CancellationToken cancellationToken = default, string name = "")
• public static class SenderContextExtensions
  • public static BatchContext CreateBatchContext(this ISenderContext context, int size, CancellationToken ct)
  • public static void Request(this ISenderContext self, PID target, object message)
  • public static Task<T> RequestAsync<T>(this ISenderContext self, PID target, object message)
  • public static Task<T> RequestAsync<T>(this ISenderContext self, PID target, object message, TimeSpan timeout)
  • public static void RequestReenter<T>(this IContext self, PID target, object message, Func<Task<T>, Task> callback, CancellationToken ct)
  • public static Task<ValueTuple<T, MessageHeader>> RequestWithHeadersAsync<T>(this ISenderContext self, PID target, object message, MessageHeader headers = null, CancellationToken cancellationToken = default)
• public sealed delegate Spawner : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(ActorSystem system, string id, Props props, PID parent, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(ActorSystem system, string id, Props props, PID parent, Action<IContext> callback, AsyncCallback __callback, object object)
  • public virtual PID Invoke(ActorSystem system, string id, Props props, PID parent)
  • public virtual PID Invoke(ActorSystem system, string id, Props props, PID parent, Action<IContext> callback = null)
• public static class SpawnerContextExtensions
  • public static PID Spawn(this ISpawnerContext self, Props props)
  • public static PID SpawnPrefix(this ISpawnerContext self, Props props, string prefix)
  • public static PID SpawnPrefix(this ISpawnerContext self, Props props, string prefix, Action<IContext> callback)
• public class Stopper
  • public string StoppedReason { get; }
  • public CancellationToken Token { get; }
  • public Stopper()
  • public void Stop(string reason = "")
• public class Subscription<T>
• public static class SystemContext
  • public static PID SpawnNamedSystem(this RootContext self, Props props, string name)
• public sealed class Terminated : SystemMessage, InfrastructureMessage, IMessage<Terminated>, IMessage, IEquatable<Terminated>, IDeepCloneable<Terminated>, IBufferMessage
  • public const int AddressTerminatedFieldNumber = 2
  • public const int WhyFieldNumber = 2
  • public bool AddressTerminated { get; set; }
  • public TerminatedReason Why { get; set; }
  • public static Terminated From(PID who)
  • public static Terminated From(PID who, TerminatedReason why)
• public static class TimeConvert
• public enum TerminatedReason
  • AddressTerminated = 1
  • NotFound = 2
  • Stopped = 0
• public sealed class Touch : IAutoRespond, InfrastructureMessage, IMessage<Touch>, IMessage, IEquatable<Touch>, IDeepCloneable<Touch>, IBufferMessage
  • public static MessageDescriptor Descriptor { get; }
  • public static MessageParser<Touch> Parser { get; }
  • public Touch()
  • public Touch(Touch other)
  • public int CalculateSize()
  • public Touch Clone()
  • public bool Equals(Touch other)
  • public object GetAutoResponse(IContext context)
  • public void MergeFrom(Touch other)
  • public void MergeFrom(CodedInputStream input)
  • public void WriteTo(CodedOutputStream output)
• public sealed class Touched : IMessage<Touched>, IMessage, IEquatable<Touched>, IDeepCloneable<Touched>, IBufferMessage
  • public const int WhoFieldNumber = 1
  • public static MessageDescriptor Descriptor { get; }
  • public static MessageParser<Touched> Parser { get; }
  • public PID Who { get; set; }
  • public Touched()
  • public Touched(Touched other)
  • public int CalculateSize()
  • public Touched Clone()
  • public bool Equals(Touched other)
  • public void MergeFrom(Touched other)
  • public void MergeFrom(CodedInputStream input)
  • public void WriteTo(CodedOutputStream output)
• public sealed class VoidResponse : IMessage<VoidResponse>, IMessage, IEquatable<VoidResponse>, IDeepCloneable<VoidResponse>
• public static class UtilExtensions
  • public static void CheckFailFast(this Exception reason)
  • public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> self, out TKey key, out TValue value)

Proto.Channels

• public static class ChannelPublisher
  • public static PID StartNew<T>(IRootContext context, Channel<T> channel, string name)
• public class ChannelPublisherActor<T> : IActor
  • public ChannelPublisherActor()
  • public Task ReceiveAsync(IContext context)
• public static class ChannelSubscriber
  • public static PID StartNew<T>(IRootContext context, PID publisher, Channel<T> channel)
• public class ChannelSubscriberActor<T> : IActor
  • public ChannelSubscriberActor(PID publisher, Channel<T> channel)
  • public Task ReceiveAsync(IContext context)

Proto.Context

• public class ActorContext : IMessageInvoker, IContext, ISenderContext, IInfoContext, IContextStore, ISystemContext, IReceiverContext, ISpawnerContext, IStopperContext, ISupervisor
  • public IActor Actor { get; }
  • public CancellationToken CancellationToken { get; }
  • public CancellationTokenSource CancellationTokenSource { get; }
  • public IImmutableSet<PID> Children { get; }
  • public MessageHeader Headers { get; }
  • public object Message { get; }
  • public PID Parent { get; }
  • public TimeSpan ReceiveTimeout { get; }
  • public PID Self { get; }
  • public PID Sender { get; }
  • public ActorSystem System { get; }
  • public ActorContext(ActorSystem system, Props props, PID parent, PID self, IMailbox mailbox)
  • public static ActorContext Setup(ActorSystem system, Props props, PID parent, PID self, IMailbox mailbox)
  • public void Apply(CapturedContext capturedContext)
  • public void CancelReceiveTimeout()
  • public CapturedContext Capture()
  • public void EscalateFailure(Exception reason, object message)
  • public void Forward(PID target)
  • public T Get<T>()
  • public IFuture GetFuture()
  • public ValueTask InvokeSystemMessageAsync(object msg)
  • public ValueTask InvokeUserMessageAsync(object msg)
  • public void Poison(PID pid)
  • public Task PoisonAsync(PID pid)
  • public Task Receive(MessageEnvelope envelope)
  • public void ReenterAfter<T>(Task<T> target, Func<Task<T>, Task> action)
  • public void ReenterAfter(Task target, Action action)
  • public void ReenterAfterCancellation(CancellationToken token, Action onCancelled)
  • public void Remove<T>()
  • public void Request(PID target, object message, PID sender)
  • public Task<T> RequestAsync<T>(PID target, object message, CancellationToken cancellationToken)
  • public void Respond(object message)
  • public void RestartChildren(Exception reason, PID[] pids)
  • public void ResumeChildren(PID[] pids)
  • public void Send(PID target, object message)
  • public void Set<T, TI>(TI obj) where TI : T
  • public void SetReceiveTimeout(TimeSpan duration)
  • public PID SpawnNamed(Props props, string name, Action<IContext> callback = null)
  • public void Stash()
  • public void Stop(PID pid)
  • public Task StopAsync(PID pid)
  • public void StopChildren(PID[] pids)
  • public void Unwatch(PID pid)
  • public void Watch(PID pid)
• public sealed class BatchContext : ISenderContext, IInfoContext, IContextStore, ISystemContext, IDisposable
  • public IActor Actor { get; }
  • public MessageHeader Headers { get; }
  • public object Message { get; }
  • public PID Parent { get; }
  • public PID Self { get; }
  • public PID Sender { get; }
  • public ActorSystem System { get; }
  • public BatchContext(ISenderContext contextContext, int batchSize, CancellationToken ct)
  • public void Dispose()
  • public T Get<T>()
  • public IFuture GetFuture()
  • public void Remove<T>()
  • public void Request(PID target, object message, PID sender)
  • public Task<T> RequestAsync<T>(PID target, object message, CancellationToken ct)
  • public void Send(PID target, object message)
  • public void Set<T, TI>(TI obj) where TI : T
• public class DeadlineContextDecorator : ActorContextDecorator
  • public DeadlineContextDecorator(IContext context, TimeSpan deadline, ILogger logger)
• public static class DeadlineContextExtensions
  • public static Props WithDeadlineDecorator(this Props props, TimeSpan deadline, ILogger logger)

Proto.Deduplication

• public class DeduplicationContext<T> : ActorContextDecorator where T : IEquatable<T>
  • public DeduplicationContext(IContext context, TimeSpan deDuplicationWindow, TryGetDeduplicationKey<T> deduplicateBy)
• public sealed delegate TryGetDeduplicationKey<T> : MulticastDelegate
  • public TryGetDeduplicationKey(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(MessageEnvelope envelope, out T key, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(out T key, IAsyncResult result)
  • public virtual bool Invoke(MessageEnvelope envelope, out T key)

Proto.DependencyInjection

• public class DependencyResolver : IDependencyResolver
  • public DependencyResolver(IServiceProvider services)
  • public Props PropsFor<TActor>(object[] args) where TActor : IActor
  • public Props PropsFor<TActor>() where TActor : IActor
  • public Props PropsFor(Type actorType)
• public class DIExtension : IActorSystemExtension<DIExtension>, IActorSystemExtension
  • public IDependencyResolver Resolver { get; }
  • public DIExtension(IDependencyResolver resolver)
• public static class Extensions
  • public static IDependencyResolver DI(this ActorSystem system)
  • public static ActorSystem WithServiceProvider(this ActorSystem actorSystem, IServiceProvider serviceProvider)
• public interface IDependencyResolver
  • Props PropsFor<TActor>(object[] args) where TActor : IActor
  • Props PropsFor<TActor>() where TActor : IActor
  • Props PropsFor(Type actorType)

Proto.Diagnostics

• public static class DiagnosticsSerializer
  • public static string Serialize(IActor actor)
• public static class DiagnosticTools
  • public static Task<string> GetDiagnosticsString(ActorSystem system, PID pid)
• public interface IActorDiagnostics
  • string GetDiagnosticsString()

Proto.Extensions

• public class ActorSystemExtensions
  • public ActorSystemExtensions(ActorSystem actorSystem)
  • public T Get<T>() where T : IActorSystemExtension
  • public T GetRequired<T>(string notFoundMessage = null) where T : IActorSystemExtension
  • public void Register<T>(IActorSystemExtension<T> extension) where T : IActorSystemExtension
• public interface IActorSystemExtension
• public interface IActorSystemExtension<T> : IActorSystemExtension where T : IActorSystemExtension
  • public static int Id

Proto.Future

• public sealed class FutureBatchProcess : Process, IDisposable
  • public PID Pid { get; }
  • public FutureBatchProcess(ActorSystem system, int size, CancellationToken ct)
  • public void Dispose()
  • public IFuture TryGetFuture()
• public sealed class FutureFactory
  • public FutureFactory(ActorSystem system, bool useSharedFutures, int sharedFutureSize)
  • public IFuture Get()
• public sealed class FutureProcess : Process, IFuture, IDisposable
  • public PID Pid { get; }
  • public Task<object> Task { get; }
  • public void Dispose()
  • public Task<object> GetTask(CancellationToken cancellationToken)
• public interface IFuture : IDisposable
  • PID Pid { get; }
  • Task<object> Task { get; }
  • Task<object> GetTask(CancellationToken cancellationToken)
• public sealed class SharedFutureProcess : Process, IDisposable
  • public int RequestsInFlight { get; }
  • public bool Stopping { get; }
  • public void Dispose()
  • public void Stop()
  • public IFuture TryCreateHandle()

Proto.Logging

• public static class Extensions
  • public static InstanceLogger Logger(this IContext context)
  • public static InstanceLogger Logger(this ActorSystem system)
• public class InstanceLogger : IActorSystemExtension<InstanceLogger>, IActorSystemExtension
  • public InstanceLogger(LogLevel logLevel, LogStore logStore = null, ILogger logger = null, string category = "default")
  • public InstanceLogger BeginMethodScope(string caller = "")
  • public InstanceLogger BeginScope<T>()
  • public InstanceLogger BeginScope(string category)
  • public void LogCritical(string template, object[] args)
  • public void LogCritical(Exception x, string template, object[] args)
  • public void LogDebug(string template)
  • public void LogDebug<T>(string template, T arg)
  • public void LogDebug<T, T2>(string template, T arg, T2 arg2)
  • public void LogDebug<T, T2, T3>(string template, T arg, T2 arg2, T3 arg3)
  • public void LogDebug(string template, object[] args)
  • public void LogDebug(Exception x, string template, object[] args)
  • public void LogError(string template, object[] args)
  • public void LogError(Exception x, string template, object[] args)
  • public void LogInformation(string template, object[] args)
  • public void LogInformation(Exception x, string template, object[] args)
  • public void LogWarning(string template, object[] args)
  • public void LogWarning(Exception x, string template, object[] args)
• public class LogStore
  • public LogStore()
  • public void Append(LogLevel logLevel, string category, string template, Exception x, object[] args)
  • public void Clear()
  • public LogStoreEntry FindEntry(string partialTemplate)
  • public LogStoreEntry FindEntryByCategory(string partialCategory, string partialTemplate)
  • public LogStoreEntry FindLastEntry(string partialTemplate)
  • public LogStoreEntry FindLastEntryByCategory(string partialCategory, string partialTemplate)
  • public IReadOnlyList<LogStoreEntry> GetEntries()
  • public string ToFormattedString()
• public class LogStoreEntry : IEquatable<LogStoreEntry>
  • public object[] Args { get; set; }
  • public string Category { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public Exception Exception { get; set; }
  • public int Index { get; set; }
  • public LogLevel LogLevel { get; set; }
  • public string Template { get; set; }
  • public DateTimeOffset Timestamp { get; set; }
  • public LogStoreEntry(int Index, DateTimeOffset Timestamp, LogLevel LogLevel, string Category, string Template, Exception Exception, object[] Args)
  • protected LogStoreEntry(LogStoreEntry original)
  • public static bool op_Equality(LogStoreEntry left, LogStoreEntry right)
  • public static bool op_Inequality(LogStoreEntry left, LogStoreEntry right)
  • public virtual LogStoreEntry <Clone>$()
  • public void Deconstruct(out int Index, out DateTimeOffset Timestamp, out LogLevel LogLevel, out string Category, out string Template, out Exception Exception, out object Args)
  • public virtual bool Equals(LogStoreEntry other)
  • public bool IsAfter(LogStoreEntry other)
  • public bool IsBefore(LogStoreEntry other)
  • protected virtual bool PrintMembers(StringBuilder builder)
  • public string ToFormattedString()
• public sealed class NullLoggerFactory : ILoggerFactory, IDisposable
  • public NullLoggerFactory()
  • public void AddProvider(ILoggerProvider provider)
  • public ILogger CreateLogger(string name)
  • public void Dispose()

Proto.Mailbox

• public class BatchingMailbox : IMailbox
  • public int UserMessageCount { get; }
  • public BatchingMailbox(int batchSize)
  • public void PostSystemMessage(object msg)
  • public void PostUserMessage(object msg)
  • public void RegisterHandlers(IMessageInvoker invoker, IDispatcher dispatcher)
  • public void Start()
• public class BoundedMailboxQueue : IMailboxQueue
  • public int Length { get; }
• public sealed class DefaultMailbox : IMailbox
  • public int UserMessageCount { get; }
  • public DefaultMailbox(IMailboxQueue systemMessages, IMailboxQueue userMailbox)
  • protected void Schedule()
• public interface IMailbox
  • int UserMessageCount { get; }
• public interface IMailboxQueue
  • int Length { get; }
• public interface IMessageInvoker
  • Task InvokeSystemMessageAsync(object msg)
  • Task InvokeUserMessageAsync(object msg)
  • ValueTask InvokeSystemMessageAsync(object msg)
  • ValueTask InvokeUserMessageAsync(object msg)
• public class LockingUnboundedMailboxQueue : IMailboxQueue
  • public bool HasMessages { get; }
  • public int Length { get; }
  • public LockingUnboundedMailboxQueue(int initialCapacity)
  • public object Pop()
  • public void Push(object message)
• public class MessageBatch : IEquatable<MessageBatch>
  • protected virtual Type EqualityContract { get; }
  • public IList<object> Messages { get; set; }
  • public MessageBatch(IList<object> Messages)
  • protected MessageBatch(MessageBatch original)
  • public static bool op_Equality(MessageBatch left, MessageBatch right)
  • public static bool op_Inequality(MessageBatch left, MessageBatch right)
  • public virtual MessageBatch <Clone>$()
  • public void Deconstruct(out IList Messages)
  • public virtual bool Equals(MessageBatch other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class NonBlockingBoundedMailbox : IMailboxQueue
  • public int Length { get; }
• public interface SystemMessage : InfrastructureMessage
  • protected SystemMessage()
• public class UnboundedMailboxQueue : IMailboxQueue
  • public int Length { get; }

Proto.Metrics

• public static class ActorMetrics
  • public static readonly Counter<long> ActorFailureCount
  • public static readonly Histogram<long> ActorMailboxLength
  • public static readonly Histogram<double> ActorMessageReceiveDuration
  • public static readonly Counter<long> ActorRestartedCount
  • public static readonly Counter<long> ActorSpawnCount
  • public static readonly Counter<long> ActorStoppedCount
  • public static readonly Counter<long> DeadletterCount
  • public static readonly Counter<long> FuturesCompletedCount
  • public static readonly Counter<long> FuturesStartedCount
  • public static readonly Counter<long> FuturesTimedOutCount
  • public static readonly Histogram<double> ThreadPoolLatency
• public class ObservableGaugeWrapper<T> where T : struct
  • public ObservableGaugeWrapper()
  • public void AddObserver(Func<IEnumerable<Measurement<T>>> observer)
  • public IEnumerable<Measurement<T>> Observe()
  • public void RemoveObserver(Func<IEnumerable<Measurement<T>>> observer)
• public class ProtoMetrics
  • public static Meter Meter
  • public const string MeterName = "Proto.Actor"
  • public readonly bool Enabled
  • public ProtoMetrics(bool enabled)

Proto.Router

• public class HashRing
• public class HashRing<T>
  • public int Count { get; }
  • public HashRing(IEnumerable<T> nodes, Func<T, string> getKey, Func<string, uint> hash, int replicaCount)
  • public void Add(T[] added)
  • public HashRing<T> Clone()
  • public T GetNode(string key)
  • public void Remove(ISet<T> nodes)
  • public void Remove(T node)
• public static class RouterExtensions
  • public static Props NewConsistentHashGroup(this ISenderContext senderContext, Func<object, string> messageHasher, PID[] routees)
  • public static Props NewConsistentHashPool(this ISenderContext senderContext, Props props, int poolSize, Func<string, uint> hash = null, int replicaCount = 100)
  • public static Props NewConsistentHashGroup(this ISenderContext senderContext, Func<string, uint> hash, int replicaCount, Func<object, string> messageHasher, PID[] routees)
  • public static Props NewConsistentHashPool(this ISenderContext senderContext, Props props, int poolSize, Func<string, uint> hash = null, int replicaCount = 100, Func<object, string> messageHasher = null)

Proto.Router.Messages

• public class Routees : IEquatable<Routees>
  • public List<PID> PIDs { get; }
  • protected virtual Type EqualityContract { get; }
  • public List<PID> Pids { get; set; }
  • protected Routees(Routees original)
  • public static bool op_Equality(Routees left, Routees right)
  • public static bool op_Inequality(Routees left, Routees right)
  • public virtual Routees <Clone>$()
  • public void Deconstruct(out List Pids)
  • public virtual bool Equals(Routees other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class RouterAddRoutee : RouterManagementMessage, IEquatable<RouterAddRoutee>
  • public PID PID { get; }
  • public PID Pid { get; set; }
  • protected RouterAddRoutee(RouterAddRoutee original)
  • public static bool op_Equality(RouterAddRoutee left, RouterAddRoutee right)
  • public static bool op_Inequality(RouterAddRoutee left, RouterAddRoutee right)
  • public void Deconstruct(out PID Pid)
  • public virtual bool Equals(RouterAddRoutee other)
• public class RouterBroadcastMessage : RouterManagementMessage, IEquatable<RouterBroadcastMessage>
  • protected RouterBroadcastMessage(RouterBroadcastMessage original)
  • public static bool op_Equality(RouterBroadcastMessage left, RouterBroadcastMessage right)
  • public static bool op_Inequality(RouterBroadcastMessage left, RouterBroadcastMessage right)
  • public void Deconstruct(out object Message)
  • public virtual bool Equals(RouterBroadcastMessage other)
• public class RouterGetRoutees : RouterManagementMessage, IEquatable<RouterGetRoutees>
  • protected RouterGetRoutees(RouterGetRoutees original)
  • public static bool op_Equality(RouterGetRoutees left, RouterGetRoutees right)
  • public static bool op_Inequality(RouterGetRoutees left, RouterGetRoutees right)
  • public virtual bool Equals(RouterGetRoutees other)
• public abstract class RouterManagementMessage : IEquatable<RouterManagementMessage>
  • protected virtual Type EqualityContract { get; }
  • protected RouterManagementMessage(RouterManagementMessage original)
  • public static bool op_Equality(RouterManagementMessage left, RouterManagementMessage right)
  • public static bool op_Inequality(RouterManagementMessage left, RouterManagementMessage right)
  • public abstract RouterManagementMessage <Clone>$()
  • public virtual bool Equals(RouterManagementMessage other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class RouterRemoveRoutee : RouterManagementMessage, IEquatable<RouterRemoveRoutee>
  • public PID PID { get; }
  • public PID Pid { get; set; }
  • protected RouterRemoveRoutee(RouterRemoveRoutee original)
  • public static bool op_Equality(RouterRemoveRoutee left, RouterRemoveRoutee right)
  • public static bool op_Inequality(RouterRemoveRoutee left, RouterRemoveRoutee right)
  • public void Deconstruct(out PID Pid)
  • public virtual bool Equals(RouterRemoveRoutee other)

Proto.Router.Routers

• public abstract class GroupRouterConfig : RouterConfig, IEquatable<GroupRouterConfig>
  • protected readonly ISenderContext SenderContext
  • public PID[] Routees { get; set; }
  • public ISenderContext SenderContext { get; set; }
  • protected GroupRouterConfig(GroupRouterConfig original)
  • public static bool op_Equality(GroupRouterConfig left, GroupRouterConfig right)
  • public static bool op_Inequality(GroupRouterConfig left, GroupRouterConfig right)
  • public abstract RouterConfig <Clone>$()
  • public void Deconstruct(out ISenderContext SenderContext, out PID Routees)
  • public virtual bool Equals(GroupRouterConfig other)
• public abstract class RouterConfig : IEquatable<RouterConfig>
  • protected virtual Type EqualityContract { get; }
  • protected RouterConfig(RouterConfig original)
  • public static bool op_Equality(RouterConfig left, RouterConfig right)
  • public static bool op_Inequality(RouterConfig left, RouterConfig right)
  • public abstract RouterConfig <Clone>$()
  • public virtual bool Equals(RouterConfig other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public abstract class RouterState
  • protected HashSet<PID> Routees
  • protected ImmutableList<PID> Values
  • protected List<PID> GetValues()
  • protected ImmutableList<PID> GetValues()
  • public virtual void SetRoutees(HashSet<PID> routees)
  • public virtual void SetRoutees(PID[] routees)

Proto.Timers

• public class Scheduler
  • public Scheduler(ISenderContext context)
  • public CancellationTokenSource RequestRepeatedly(TimeSpan delay, TimeSpan interval, PID target, object message)
  • public CancellationTokenSource SendOnce(TimeSpan delay, PID target, object message)
  • public CancellationTokenSource SendRepeatedly(TimeSpan interval, PID target, object message)
  • public CancellationTokenSource SendRepeatedly(TimeSpan delay, TimeSpan interval, PID target, object message)
• public static class TimerExtensions
  • public static Scheduler Scheduler(this ISenderContext context)

Proto.Utils

• public class AsyncSemaphore
  • public AsyncSemaphore(int maxConcurrency)
  • public void Wait(Func<Task> producer)
  • public Task<T> WaitAsync<T>(Func<Task<T>> producer)
  • public Task WaitAsync(Func<Task> producer)
• public abstract class ConcurrentKeyValueStore<T> : IKeyValueStore<T>
  • protected ConcurrentKeyValueStore(AsyncSemaphore semaphore)
  • public Task ClearAsync(string id, CancellationToken ct)
  • public Task<T> GetAsync(string id, CancellationToken ct)
  • protected abstract Task InnerClearStateAsync(string id, CancellationToken ct)
  • protected abstract Task<T> InnerGetStateAsync(string id, CancellationToken ct)
  • protected abstract Task InnerSetStateAsync(string id, T state, CancellationToken ct)
  • public Task SetAsync(string id, T state, CancellationToken ct)
• public class ConcurrentSet<T>
  • public ConcurrentSet()
  • public void Add(T key)
  • public bool Contains(T key)
  • public void Remove(T key)
  • public T[] ToArray()
  • public bool TryAdd(T key)
• public class EmptyKeyValueStore<T> : IKeyValueStore<T>
  • public EmptyKeyValueStore()
  • public Task ClearAsync(string id, CancellationToken ct)
  • public Task<T> GetAsync(string id, CancellationToken ct)
  • public Task SetAsync(string id, T state, CancellationToken ct)
• public interface IKeyValueStore<T>
  • Task ClearAsync(string id, CancellationToken ct)
  • Task<T> GetAsync(string id, CancellationToken ct)
  • Task SetAsync(string id, T state, CancellationToken ct)
• public static class Retry
  • public class RetriesExhaustedException : Exception
  • public const int Forever = 0
  • public static Task<T> Try<T>(Func<Task<T>> body, int retryCount = 10, int backoffMilliSeconds = 100, int maxBackoffMilliseconds = 5000, Action<int, Exception> onError = null, Action<Exception> onFailed = null)
  • public static Task Try(Func<Task> body, int retryCount = 10, int backoffMilliSeconds = 100, int maxBackoffMilliseconds = 5000, Action<int, Exception> onError = null, Action<Exception> onFailed = null, bool ignoreFailure = false)
  • public static Task<T> TryUntil<T>(Func<Task<T>> body, Func<T, bool> condition, int retryCount = 10, int backoffMilliSeconds = 100, int maxBackoffMilliseconds = 5000, Action<int, Exception> onError = null, Action<Exception> onFailed = null)
  • public static Task<T> TryUntilNotNull<T>(Func<Task<T>> body, int retryCount = 10, int backoffMilliSeconds = 100, int maxBackoffMilliseconds = 5000, Action<int, Exception> onError = null, Action<Exception> onFailed = null)
• public sealed delegate ShouldThrottle : MulticastDelegate
  • public ShouldThrottle(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual Valve EndInvoke(IAsyncResult result)
  • public virtual Valve Invoke()
• public class TaskClock
  • public Task CurrentBucket { get; }
  • public TaskClock(TimeSpan timeout, TimeSpan updateInterval, CancellationToken ct)
  • public void Start()
• public static class TaskExtensions
  • public static Task<bool> WaitUpTo(this Task task, TimeSpan timeout, CancellationToken? ct = default)
  • public static Task<ValueTuple<bool, TResult>> WaitUpTo<TResult>(this Task<TResult> task, TimeSpan timeout, CancellationToken? ct = default)
  • public static Task<TResult> WithTimeout<TResult>(this Task<TResult> task, TimeSpan timeout, CancellationToken? ct = default)
• public static class ThreadPoolStats
  • public static Task Run(TimeSpan interval, Action<TimeSpan> callback, CancellationToken cancellationToken = default)
• public static class Throttle
  • public enum Valve
  • public static ShouldThrottle Create(int maxEventsInPeriod, TimeSpan period, Action<int> throttledCallBack = null)
  • public static ShouldThrottle Create(this ThrottleOptions options, Action<int> throttledCallBack = null)
  • public static bool IsOpen(this Valve valve)
• public class ThrottleOptions : IEquatable<ThrottleOptions>
  • protected virtual Type EqualityContract { get; }
  • public int MaxEventsInPeriod { get; set; }
  • public TimeSpan Period { get; set; }
  • public ThrottleOptions(int MaxEventsInPeriod, TimeSpan Period)
  • protected ThrottleOptions(ThrottleOptions original)
  • public static bool op_Equality(ThrottleOptions left, ThrottleOptions right)
  • public static bool op_Inequality(ThrottleOptions left, ThrottleOptions right)
  • public virtual ThrottleOptions <Clone>$()
  • public void Deconstruct(out int MaxEventsInPeriod, out TimeSpan Period)
  • public virtual bool Equals(ThrottleOptions other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class TypeDictionary<TValue, TNamespace>
  • public TypeDictionary(int initialSize = 100, double growthFactor = 2)
  • public void Add<TKey>(TValue value)
  • public TValue Get<TKey>()
  • public void Remove<TKey>()