/// <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;
}
