/// <summary>
/// Get actor, if already exist, will return or create new one
/// </summary>
/// <typeparam name="T">actor type</typeparam>
/// <param name="actorKey">actor key</param>
/// <returns>actor instance</returns>
public T GetActor <T>(ActorKey actorKey) where T : IActor
{
actorKey.VerifyNotNull(nameof(actorKey));
Type actoryType = typeof(T);
lock (_lock)
{
if (_actorCollection.TryGetValue(actoryType, actorKey, out ActorInstance actorInstance))
{
_logger.LogInformation($"{nameof(GetActor)}: found instance, actorKey={actorKey}, actorInstance.ActorKey={actorInstance.ActorKey}");
return((T)actorInstance.GetInstance <T>());
}
// Create actor object
IActorBase actorBase = _registry.Create <T>(actorKey, this);
(actorKey == actorBase.ActorKey).VerifyAssert(x => x, $"{nameof(GetActor)}: CREATED-Error Actor key !=, actorKey={actorKey}, actorBase.ActorKey={actorBase.ActorKey}");
_logger.LogTrace($"{nameof(GetActor)}: CREATED actorBase.ActorKey={actorBase.ActorKey}");
// Create proxy
T actorInterface = ActorProxy <T> .Create(actorBase, this);
actorInstance = new ActorInstance(typeof(T), actorKey, actorBase, actorInterface);
// Add to actor collection
_actorCollection.Set(actorInstance);
// Create proxy for interface
return(actorInstance.GetInstance <T>());
}
}
/// <summary>
/// Get actor, if already exist, will return or create new one
/// </summary>
/// <typeparam name="T">actor type</typeparam>
/// <param name="actorKey">actor key</param>
/// <returns>actor instance</returns>
public T GetActor <T>(ActorKey actorKey) where T : IActor
{
actorKey.VerifyNotNull(nameof(actorKey));
Type actoryType = typeof(T);
lock (_lock)
{
if (_actorCollection.TryGetValue(actoryType, actorKey, out ActorInstance actorInstance))
{
return((T)actorInstance.GetInstance <T>());
}
// Create actor object
IActorBase actorBase = _registry.Create <T>(actorKey, this);
// Create proxy
T actorInterface = ActorProxy <T> .Create(actorBase, this);
actorInstance = new ActorInstance(typeof(T), actorKey, actorBase, actorInterface);
// Add to actor collection
_actorCollection.Set(actorInstance);
// Create proxy for interface
return(actorInstance.GetInstance <T>());
}
}
/// <summary>
/// Dispose
/// </summary>
public void Dispose()
{
ActorProxy = null;
IActorBase current = Interlocked.Exchange(ref _instance, null);
current?.Dispose();
}
public GameRoom(IMapActor map, IActorBase illumination, IEnemyManager enemyManager,
IPlayerManager playerManager)
{
_map = map;
_illumination = illumination;
_enemyManager = enemyManager;
_playerManager = playerManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="actorType">actor type</param>
/// <param name="actorKey">actor key</param>
/// <param name="instance">instance of the actor class</param>
/// <param name="actorProxy">actor proxy</param>
public ActorRegistration(Type actorType, ActorKey actorKey, IActorBase instance, IActor actorProxy)
{
Verify.IsNotNull(nameof(actorType), actorType);
Verify.IsNotNull(nameof(actorKey), actorKey);
Verify.IsNotNull(nameof(instance), instance);
Verify.IsNotNull(nameof(actorProxy), actorProxy);
ActorType = actorType;
ActorKey = actorKey;
_instance = instance;
ActorProxy = actorProxy;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="actorType">actor type</param>
/// <param name="actorKey">actor key</param>
/// <param name="instance">instance of the actor class</param>
/// <param name="actorProxy">actor proxy</param>
public ActorRegistration(Type actorType, ActorKey actorKey, IActorBase instance, IActor actorProxy)
{
actorType.Verify(nameof(actorType)).IsNotNull();
actorKey.Verify(nameof(actorKey)).IsNotNull();
instance.Verify(nameof(instance)).IsNotNull();
actorProxy.Verify(nameof(actorProxy)).IsNotNull();
ActorType = actorType;
ActorKey = actorKey;
_instance = instance;
_actorProxy = actorProxy;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="actorType">actor type</param>
/// <param name="actorKey">actor key</param>
/// <param name="instance">instance of the actor class</param>
/// <param name="actorProxy">actor proxy</param>
public ActorInstance(Type actorType, ActorKey actorKey, IActorBase instance, IActor actorProxy)
{
actorType.VerifyNotNull(nameof(actorType));
actorKey.VerifyNotNull(nameof(actorKey));
instance.VerifyNotNull(nameof(instance));
actorProxy.VerifyNotNull(nameof(actorProxy));
ActorType = actorType;
ActorKey = actorKey;
_instance = instance;
_actorProxy = actorProxy;
}
private ActorProxy(IActorBase instance, IActorManager manager)
: base(typeof(T))
{
Verify.IsNotNull(nameof(instance), instance);
Verify.IsNotNull(nameof(manager), manager);
_instance = instance;
_manager = manager;
_workContext = new WorkContextBuilder()
.Set(_tag)
.Set(_cv)
.Build();
}
/// <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(IActorBase instance, ActorHost actorHost)
{
instance.VerifyNotNull(nameof(instance));
actorHost.VerifyNotNull(nameof(actorHost));
object proxyObject = Create <T, ActorProxy <T> >();
ActorProxy <T> proxy = (ActorProxy <T>)proxyObject;
proxy._instance = instance;
proxy._actorHost = actorHost;
return((T)proxyObject);
}
/// <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 virtual actor, return current instance or create one
/// </summary>
/// <typeparam name="T">actor interface</typeparam>
/// <param name="context">context</param>
/// <param name="actorKey">actor key</param>
/// <returns>actor proxy interface</returns>
public async Task <T> CreateProxyAsync <T>(IWorkContext context, ActorKey actorKey) where T : IActor
{
Verify.Assert(IsRunning, _disposedTestText);
Verify.IsNotNull(nameof(context), context);
Verify.IsNotNull(nameof(context), context);
Verify.IsNotNull(nameof(actorKey), actorKey);
context = context.WithTag(_tag);
Type actorType = typeof(T);
// Lookup instance of actor (type + actorKey)
IActorRegistration actorRegistration = _actorRepository.Lookup(actorType, actorKey);
if (actorRegistration != null)
{
return(actorRegistration.GetInstance <T>());
}
// Create actor
IActor actorObject = _typeManager.Create <T>(context, actorKey, this);
IActorBase actorBase = actorObject as IActorBase;
if (actorBase == null)
{
var ex = new ArgumentException($"Actor {actorObject.GetType().FullName} does not implement IActorBase");
Configuration.WorkContext.EventLog.Error(context, "Cannot create", ex);
throw ex;
}
T actorInterface = ActorProxy <T> .Create(context, actorBase, this);
actorRegistration = new ActorRegistration(typeof(T), actorKey, actorBase, actorInterface);
await _actorRepository.SetAsync(context, actorRegistration);
// Create proxy for interface
return(actorRegistration.GetInstance <T>());
}
/// <summary>
/// Create transparent proxy for instance of actor class
/// </summary>
/// <param name="instance">instance of actor class</param>
/// <param name="manager">actor manager</param>
/// <returns>proxy</returns>
public static T Create(IActorBase instance, IActorManager manager)
{
return((T) new ActorProxy <T>(instance, manager).GetTransparentProxy());
}
