/// <summary> /// Initializes a new instance of the <see cref="Actor"/> class. /// </summary> /// <param name="host">The <see cref="ActorHost"/> that will host this actor instance.</param> protected Actor(ActorHost host) { this.Host = host; this.StateManager = new ActorStateManager(this); this.actorTypeName = this.Host.ActorTypeInfo.ActorTypeName; this.Logger = host.LoggerFactory.CreateLogger(this.GetType()); }
/// <summary> /// Creates the actor instance and returns it inside an instance of <see cref="ActorActivatorState" />. /// </summary> /// <param name="host">The actor host specifying information needed for the creation of the actor.</param> /// <returns> /// Asynchronously returns n instance of <see cref="ActorActivatorState" />. The <see cref="ActorActivatorState" /> /// instance will be provided to <see cref="DeleteAsync" /> when the actor is ready for deletion. /// </returns> /// <remarks> /// Implementations should not interact with lifecycle callback methods on the <see cref="Actor" /> type. /// These methods will be called by the runtime. /// </remarks> public override Task <ActorActivatorState> CreateAsync(ActorHost host) { var type = host.ActorTypeInfo.ImplementationType; var actor = (Actor)Activator.CreateInstance(type, args: new object[] { host, }); return(Task.FromResult(new ActorActivatorState(actor))); }
public async Task CreateAsync_CallsConstructor() { var activator = new DefaultActorActivator(); var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state = await activator.CreateAsync(host); Assert.IsType <TestActor>(state.Actor); }
public async Task CreateAsync_CallsConstructor() { var activator = new DefaultActorActivator(); var host = ActorHost.CreateForTest <TestActor>(); var state = await activator.CreateAsync(host); Assert.IsType <TestActor>(state.Actor); }
public async Task DeleteAsync_NotDisposable() { var activator = new DefaultActorActivator(); var host = ActorHost.CreateForTest <TestActor>(); var actor = new TestActor(host); var state = new ActorActivatorState(actor); await activator.DeleteAsync(state); // does not throw }
public async Task DeleteAsync_NotDisposable() { var activator = new DefaultActorActivator(); var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var actor = new TestActor(host); var state = new ActorActivatorState(actor); await activator.DeleteAsync(state); // does not throw }
public async Task DeleteAsync_Disposable() { var activator = new DefaultActorActivator(); var host = new ActorHost(ActorTypeInformation.Get(typeof(DisposableActor)), ActorId.CreateRandom(), NullLoggerFactory.Instance); var actor = new DisposableActor(host); var state = new ActorActivatorState(actor); await activator.DeleteAsync(state); // does not throw Assert.True(actor.IsDisposed); }
public async Task DeleteAsync_AsyncDisposable() { var activator = new DefaultActorActivator(); var host = ActorHost.CreateForTest <AsyncDisposableActor>(); var actor = new AsyncDisposableActor(host); var state = new ActorActivatorState(actor); await activator.DeleteAsync(state); Assert.True(actor.IsDisposed); }
public async Task DeleteAsync_AsyncDisposable() { var activator = new DefaultActorActivator(); var host = new ActorHost(ActorTypeInformation.Get(typeof(AsyncDisposableActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var actor = new AsyncDisposableActor(host); var state = new ActorActivatorState(actor); await activator.DeleteAsync(state); Assert.True(actor.IsDisposed); }
public async Task CreateAsync_CanActivateWithDI() { var activator = CreateActivator(typeof(TestActor)); var host = ActorHost.CreateForTest <TestActor>(); var state = await activator.CreateAsync(host); var actor = Assert.IsType <TestActor>(state.Actor); Assert.NotNull(actor.SingletonService); Assert.NotNull(actor.ScopedService); }
public async Task CreateAsync_CanActivateWithDI() { var activator = CreateActivator(typeof(TestActor)); var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state = await activator.CreateAsync(host); var actor = Assert.IsType <TestActor>(state.Actor); Assert.NotNull(actor.SingletonService); Assert.NotNull(actor.ScopedService); }
public async Task DeleteAsync_Disposable() { var activator = CreateActivator(typeof(DisposableActor)); var host = new ActorHost(ActorTypeInformation.Get(typeof(DisposableActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state = await activator.CreateAsync(host); var actor = Assert.IsType <DisposableActor>(state.Actor); await activator.DeleteAsync(state); // does not throw Assert.True(actor.IsDisposed); }
public async Task DeleteAsync_AsyncDisposable() { var activator = CreateActivator(typeof(AsyncDisposableActor)); var host = new ActorHost(ActorTypeInformation.Get(typeof(AsyncDisposableActor)), ActorId.CreateRandom(), NullLoggerFactory.Instance); var state = await activator.CreateAsync(host); var actor = Assert.IsType <AsyncDisposableActor>(state.Actor); await activator.DeleteAsync(state); Assert.True(actor.IsDisposed); }
public async Task DeleteAsync_AsyncDisposable() { var activator = CreateActivator(typeof(AsyncDisposableActor)); var host = ActorHost.CreateForTest <AsyncDisposableActor>(); var state = await activator.CreateAsync(host); var actor = Assert.IsType <AsyncDisposableActor>(state.Actor); await activator.DeleteAsync(state); Assert.True(actor.IsDisposed); }
public async Task CreateAsync_CustomJsonOptions() { var jsonOptions = new System.Text.Json.JsonSerializerOptions { PropertyNameCaseInsensitive = false }; var activator = CreateActivator(typeof(TestActor)); var host = ActorHost.CreateForTest <TestActor>(new ActorTestOptions { JsonSerializerOptions = jsonOptions }); var state = await activator.CreateAsync(host); Assert.Same(jsonOptions, state.Actor.Host.JsonSerializerOptions); }
public async Task DeleteAsync_DisposesScope() { var activator = CreateActivator(typeof(TestActor)); var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state = await activator.CreateAsync(host); var actor = Assert.IsType <TestActor>(state.Actor); Assert.False(actor.ScopedService.IsDisposed); await activator.DeleteAsync(state); Assert.True(actor.ScopedService.IsDisposed); }
public async Task DeleteAsync_DisposesScope() { var activator = CreateActivator(typeof(TestActor)); var host = ActorHost.CreateForTest <TestActor>(); var state = await activator.CreateAsync(host); var actor = Assert.IsType <TestActor>(state.Actor); Assert.False(actor.ScopedService.IsDisposed); await activator.DeleteAsync(state); Assert.True(actor.ScopedService.IsDisposed); }
public async Task CreateAsync_CreatesNewScope() { var activator = CreateActivator(typeof(TestActor)); var host1 = ActorHost.CreateForTest <TestActor>(); var state1 = await activator.CreateAsync(host1); var actor1 = Assert.IsType <TestActor>(state1.Actor); var host2 = ActorHost.CreateForTest <TestActor>(); var state2 = await activator.CreateAsync(host2); var actor2 = Assert.IsType <TestActor>(state2.Actor); Assert.Same(actor1.SingletonService, actor2.SingletonService); Assert.NotSame(actor1.ScopedService, actor2.ScopedService); }
public async Task CreateAsync_CreatesNewScope() { var activator = CreateActivator(typeof(TestActor)); var host1 = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state1 = await activator.CreateAsync(host1); var actor1 = Assert.IsType <TestActor>(state1.Actor); var host2 = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory); var state2 = await activator.CreateAsync(host2); var actor2 = Assert.IsType <TestActor>(state2.Actor); Assert.Same(actor1.SingletonService, actor2.SingletonService); Assert.NotSame(actor1.ScopedService, actor2.ScopedService); }
public override async Task <ActorActivatorState> CreateAsync(ActorHost host) { var scope = services.CreateScope(); try { var factory = LazyInitializer.EnsureInitialized( ref this.factory, ref this.initialized, ref this.@lock, this.initializer); var actor = (Actor)factory(scope.ServiceProvider, new object[] { host }); return(new State(actor, scope)); } catch { // Make sure to clean up the scope if we fail to create the actor; await DisposeCore(scope); throw; } }
internal void ValidateTimerCallback(ActorHost host, string callback) { var actorTypeName = host.ActorTypeInfo.ActorTypeName; var actorType = host.ActorTypeInfo.ImplementationType; MethodInfo methodInfo; try { methodInfo = this.GetMethodInfoUsingReflection(actorType, callback); } catch (AmbiguousMatchException) { // GetMethod will throw an AmbiguousMatchException if more than one methods are found with the same name throw new ArgumentException($"Timer callback method: {callback} cannot be overloaded."); } // Check if the method exists if (methodInfo == null) { throw new ArgumentException($"Timer callback method: {callback} does not exist in the Actor class: {actorTypeName}"); } // The timer callback can accept only 0 or 1 parameters var parameters = methodInfo.GetParameters(); if (parameters.Length > 1) { throw new ArgumentException("Timer callback can accept only zero or one parameters"); } // The timer callback should return only Task return type if (methodInfo.ReturnType != typeof(Task)) { throw new ArgumentException("Timer callback can only return type Task"); } }
public override Task <ActorActivatorState> CreateAsync(ActorHost host) { CreateCallCount++;; return(base.CreateAsync(host)); }
public AsyncDisposableActor(ActorHost host) : base(host) { }
public TestActor(ActorHost host) : base(host) { }
public TestActor(ActorHost host) : base(host) { Sequence = Interlocked.Increment(ref counter); }
public ThrowsDuringOnDeactivateAsync(ActorHost host) : base(host) { }
/// <summary> /// Creates the actor instance and returns it inside an instance of <see cref="ActorActivatorState" />. /// </summary> /// <param name="host">The actor host specifying information needed for the creation of the actor.</param> /// <returns> /// Asynchronously returns n instance of <see cref="ActorActivatorState" />. The <see cref="ActorActivatorState" /> /// instance will be provided to <see cref="DeleteAsync" /> when the actor is ready for deletion. /// </returns> /// <remarks> /// Implementations should not interact with lifecycle callback methods on the <see cref="Actor" /> type. /// These methods will be called by the runtime. /// </remarks> public abstract Task <ActorActivatorState> CreateAsync(ActorHost host);
public TestActor(ActorHost host, TestSingletonService singletonService, TestScopedService scopedService) : base(host) { this.SingletonService = singletonService; this.ScopedService = scopedService; }