/// <summary>
/// Create transparent proxy for instance of actor class
/// </summary>
/// <param name="context">work context</param>
/// <param name="instance">instance of actor class</param>
/// <param name="manager">actor manager</param>
/// <returns>proxy</returns>
public static T Create(IWorkContext context, IActorBase instance, IActorManager manager)
{
context.Verify(nameof(context)).IsNotNull();
instance.Verify(nameof(instance)).IsNotNull();
manager.Verify(nameof(manager)).IsNotNull();
object proxyObject = Create <T, ActorProxy <T> >();
ActorProxy <T> proxy = (ActorProxy <T>)proxyObject;
proxy._instance = instance;
proxy._manager = manager;
proxy._workContext = new WorkContextBuilder(context)
.Set(_tag)
.Set(_cv)
.Build();
return((T)proxyObject);
}
/// <summary>
/// Create actor from either lambda or activator
/// </summary>
/// <typeparam name="T">actor interface</typeparam>
/// <param name="context">context</param>
/// <param name="actorKey">actor key</param>
/// <param name="manager">actor manager</param>
/// <returns>instance of actor implementation</returns>
public T Create <T>(IWorkContext context, ActorKey actorKey, IActorManager manager) where T : IActor
{
context.Verify(nameof(context)).IsNotNull();
actorKey.Verify(nameof(actorKey)).IsNotNull();
manager.Verify(nameof(manager)).IsNotNull();
typeof(T).IsInterface.Verify().Assert(x => x == true, $"{typeof(T)} must be an interface");
context = context.With(_tag);
Type actorType = typeof(T);
ActorTypeRegistration?typeRegistration = GetTypeRegistration(actorType) ?? GetTypeFromDi(context, actorType);
if (typeRegistration == null)
{
var ex = new KeyNotFoundException($"Registration for {actorType.FullName} was not found");
context.Telemetry.Error(context.With(_tag), "create failure", ex);
throw ex;
}
IActor actorObject = typeRegistration.CreateImplementation(context);
// Set actor key and manager
ActorBase?actorBase = actorObject as ActorBase;
if (actorBase == null)
{
string failureMsg = $"Created actor type {actorObject.GetType()} does not derive from ActorBase";
context.Telemetry.Error(context.With(_tag), failureMsg);
throw new InvalidOperationException(failureMsg);
}
actorBase.ActorKey = actorKey;
actorBase.ActorManager = manager;
actorBase.ActorType = actorType;
return((T)actorObject);
}
public RouteManager(IActorManager actorManager)
{
actorManager.Verify(nameof(actorManager)).IsNotNull();
_actorManager = actorManager;
}
