private IActorRef CreateActor(WorldActorState state, CreatePlayerEntityActorMessage message) { //Create the actor and tell it to initialize. IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultPlayerEntityActor>(), message.EntityGuid.RawGuidValue.ToString()); DefaultPlayerEntityActor.InitializeActor(actorRef, new DefaultPlayerEntityActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, InterestMappable.RetrieveEntity(message.EntityGuid), SendServiceMappable.RetrieveEntity(message.EntityGuid))); //Actors aren't removed from this //they are just replaced with nobody. if (ActorRefMappable.ContainsKey(message.EntityGuid)) { //If nobody, all good. Otherwise THIS SHOULD NEVER HAPPEN if (ActorRefMappable[message.EntityGuid].IsNobody()) { ActorRefMappable.ReplaceObject(message.EntityGuid, actorRef); } else { throw new InvalidOperationException($"World attempted to spawn multiple of the same player actor/"); //this will literally kill the world actor. } } else { ActorRefMappable.AddObject(message.EntityGuid, actorRef); } if (Logger.IsInfoEnabled) { Logger.Info($"Created Player Actor: {typeof(DefaultPlayerEntityActor)} for Entity: {message.EntityGuid}"); } return(actorRef); }
public void MultipleValuesFoundTest() { ApplicationContext context = new ApplicationContext(); context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10))); context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10))); context.Resolve <int>(); }
private IStream <SearchDeviceState> CreateStateStream() { if (_stream != null) { return(_stream); } var taskRunService = Task.Create(_service.RunService); var taskStartSearching = Task.Create(_service.StartSearching); var taskStopSearching = Task.Create(_service.StopSearching); var taskStopService = Task.Create(_service.StopService); var resolveRunService = Resolver.Create <SearchDeviceState>(previous => previous == SearchDeviceState.STOP_SERVICE); var resolveStartSearching = Resolver.Create <SearchDeviceState>( (previous) => { return((previous == SearchDeviceState.RUN_SERVICE) || (previous == SearchDeviceState.STOP_SEARCHING)); }); var resolveStopSearching = Resolver.Create <SearchDeviceState>( previous => previous == SearchDeviceState.START_SEARCHING ); var resolveStopService = Resolver.Create <SearchDeviceState>( previous => previous != SearchDeviceState.STOP_SERVICE ); var transitions = TransitionPool.Create( new Dictionary <SearchDeviceState, ITransition <SearchDeviceState> > { { SearchDeviceState.RUN_SERVICE, Transition.Create <SearchDeviceState>( SearchDeviceState.RUN_SERVICE, taskRunService, resolveRunService ) }, { SearchDeviceState.START_SEARCHING, Transition.Create <SearchDeviceState>( SearchDeviceState.START_SEARCHING, taskStartSearching, resolveStartSearching ) }, { SearchDeviceState.STOP_SEARCHING, Transition.Create <SearchDeviceState>( SearchDeviceState.STOP_SEARCHING, taskStopSearching, resolveStopSearching ) }, { SearchDeviceState.STOP_SERVICE, Transition.Create <SearchDeviceState>( SearchDeviceState.STOP_SERVICE, taskStopService, resolveStopService ) } } ); return(Stream.Create(SearchDeviceState.RUN_SERVICE, transitions)); }
public void DependencyTest() { ApplicationContext context = new ApplicationContext(); context.Resolvers.Add(Resolver.Create(new Func <int, double>((a) => 10.1))); context.Resolvers.Add(Resolver.Create(new Func <int>(() => 5))); double value = context.Resolve <double>(); Assert.AreEqual(10.1, value); }
public void PrototypeTest() { ApplicationContext context = new ApplicationContext(); context.Resolvers.Add(Resolver.Create(new Func <object>(() => new object()), Scope.Prototype)); object first = context.Resolve <object>(); object second = context.Resolve <object>(); Assert.AreNotSame(first, second); }
public void MergedDependencySingletonsTest() { ApplicationContext firstContext = new ApplicationContext(); firstContext.Resolvers.Add(Resolver.Create(new Func <int, double>((a) => 10.1))); ApplicationContext context = firstContext.WithSingletons(5); double value = context.Resolve <double>(); Assert.AreEqual(10.1, value); }
public void ResolveAllWithListTypeTest() { ApplicationContext context = new ApplicationContext(); context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10))); context.Resolvers.Add(Resolver.Create(new Func <int>(() => 5))); List <int> values = context.Resolve <List <int> >(); Assert.IsTrue(values.Contains(10)); Assert.IsTrue(values.Contains(5)); }
public App() { // initialize DI container Resolver.Create(); ProcessService = new LauncherProcessService(); Logger = Resolver.Kernel.Get <ILog>(); SettingsService = Resolver.Kernel.Get <ISettingsService>(); VersionService.SetVersion(new LauncherVersion("beta")); }
public void ResolveAllSubclassTest() { ApplicationContext context = new ApplicationContext(); context.Resolvers.Add(Resolver.Create(new Func <A>(() => new A()))); context.Resolvers.Add(Resolver.Create(new Func <B>(() => new B()))); context.Resolvers.Add(Resolver.Create(new Func <C>(() => new C()))); List <A> aValues = context.ResolveAll <A>(); List <B> bValues = context.ResolveAll <B>(); List <I> iValues = context.ResolveAll <I>(); Assert.AreEqual(2, aValues.Count); Assert.AreEqual(1, bValues.Count); Assert.AreEqual(3, iValues.Count); }
public virtual object Create() { if (container.registeredTypes.ContainsKey(ToType)) { Resolver nextResolver = container.registeredTypes[ToType]; if (nextResolver != this) { return(nextResolver.Create()); } else { return(container.Create(ToType)); } } return(container.Create(ToType)); }
private void CreateActor(WorldActorState state, CreateGameObjectEntityActorMessage message) { //Even visual objects now get actors EntityActorCreationResult actorCreationData = EntityActorFactory.Create(message.EntityGuid); //Create the actor and tell it to initialize. IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create(actorCreationData.DesiredActorType), message.EntityGuid.RawGuidValue.ToString()); actorRef.Tell(actorCreationData.InitializationMessage); ActorRefMappable.AddObject(message.EntityGuid, actorRef); if (Logger.IsInfoEnabled) { Logger.Info($"Created GameObject Actor: {actorCreationData.DesiredActorType} for Entity: {message.EntityGuid}"); } }
private void CreateActor(WorldActorState state, CreateCreatureEntityActorMessage message) { //Create the actor and tell it to initialize. IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultCreatureEntityActor>(), message.EntityGuid.RawGuidValue.ToString()); //TODO: Move to factory. CreatureInstanceModel instanceModel = CreatureInstanceMappable.RetrieveEntity(message.EntityGuid); CreatureTemplateModel templateModel = CreatureTemplateMappable.RetrieveEntity(message.EntityGuid); DefaultCreatureEntityActor.InitializeActor(actorRef, new DefaultCreatureActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, instanceModel, templateModel, InterestMappable.RetrieveEntity(message.EntityGuid))); ActorRefMappable.AddObject(message.EntityGuid, actorRef); if (Logger.IsInfoEnabled) { Logger.Info($"Created Creature Actor: {typeof(DefaultCreatureEntityActor)} for Entity: {message.EntityGuid}"); } }
static void Main(string[] args) { Resolver resolver = new Resolver(); resolver.Register <IBaseConfig>(() => { return(new BaseConfig()); }, LifeTimeType.SingletonFunc); var f1 = new Func <IBaseHandler> (() => { return(new BaseHandler(resolver.Create <IBaseConfig>())); }); var f = new TimedSingleton(new System.TimeSpan(0, 0, 4)).SingletonFunc <IBaseHandler>(f1); resolver.Register( new TimedSingleton(new System.TimeSpan(0, 0, 4)) .SingletonFunc( new Func <IBaseHandler>( () => { return(new BaseHandler(resolver.Create <IBaseConfig>())); }) )); var handler = resolver.Create <IBaseHandler>(); handler.Handle(); var handler2 = resolver.Create <IBaseHandler>(); handler2.Handle(); System.Threading.Thread.Sleep(5000); var handler3 = resolver.Create <IBaseHandler>(); handler3.Handle(); var handler4 = resolver.Create <IBaseHandler>(); handler4.Handle(); }