public void TestBaseType() { _counter = 0; var container = new CryoContainer(); container.RegisterType <MyBaseClass, MyClass>(CreateMyClass); var a = container.Resolve <MyBaseClass>(); Assert.IsNotNull(a); Assert.IsInstanceOf(typeof(MyClass), a); Assert.AreEqual(1, ((MyClass)a).InstanceId); Assert.AreEqual(1, _counter); a = container.Resolve <MyBaseClass>(); Assert.IsNotNull(a); Assert.IsInstanceOf(typeof(MyClass), a); Assert.AreEqual(2, ((MyClass)a).InstanceId); Assert.AreEqual(2, _counter); a = container.Resolve <MyBaseClass>(); Assert.IsNotNull(a); Assert.IsInstanceOf(typeof(MyClass), a); Assert.AreEqual(3, ((MyClass)a).InstanceId); Assert.AreEqual(3, _counter); }
public void TestSingletonByName() { var container = new CryoContainer(); container.RegisterSingleton <MyClazz>("MyClazz"); Assert.IsNull(container.WeakResolveByName <MyClazz>("MyClazz")); var clazz = container.ResolveByName <MyClazz>("MyClazz"); Assert.IsNotNull(clazz); var clazz2 = container.WeakResolveByName <MyClazz>("MyClazz"); Assert.IsNotNull(clazz2); Assert.AreSame(clazz, clazz2); try { container.WeakResolve <MyClazz>(); Assert.Fail("Exception expected"); //ascxasxasxasx } catch (ContainerException) { return; } }
public object GetObject(object owner, CryoContainer container, params object[] parameters) { if (IsDestroyed()) { _cached = FindObject(); if (_cached is CryoBehaviour cryoBehaviour) { if (!cryoBehaviour.BuiltUp) { cryoBehaviour.BuildUp(); } } else if (_cached is Component component) { var cryoBuilder = component.GetComponent <CryoBuilder>(); if (cryoBuilder != null && !cryoBuilder.BuiltUp) { cryoBuilder.BuildUp(); } } LifeTimeManager.TryToAdd(this, LifeTime); } return(_cached); }
public object GetObject(object owner, CryoContainer container, params object[] parameters) { var component = FindComponentAt(owner); if (component is CryoBehaviour cryoBehaviour) { if (!cryoBehaviour.BuiltUp) { cryoBehaviour.BuildUp(); } } else { var cryoBuilder = component.GetComponent <CryoBuilder>(); if (cryoBuilder != null && !cryoBuilder.BuiltUp) { cryoBuilder.BuildUp(); } } if (component is IDisposable disposable) { _lifeTimeManager.Add(disposable, LifeTime); } return(component); }
public object WeakGetObject(CryoContainer container, params object[] unused) { if (_disposed) { return(null); } return(_instance); }
public object GetObject(object owner, CryoContainer container, params object[] unused) { if (_disposed) { throw new ContainerException("Instance of type " + typeof(T) + " already disposed"); } return(_instance); }
public object GetObject(CryoContainer container, params object[] parameters) { var obj = _factoryMethod(); container.BuildUp(obj, parameters); LifeTimeManager.TryToAdd(obj, LifeTime); return(obj); }
public void SelfReference() { var container = new CryoContainer { CircularDependencyReaction = Reaction.LogWarning }; container.RegisterSingleton <ClassC>(); container.Resolve <ClassC>(); }
public void OnSetup() { var container = new CryoContainer(); container.RegisterInstance(new Mock <IErrorMessageController>().Object); container.RegisterSingleton <IPathfindingAlgorithm, AstarAlgorithm>(); _pathfindingAlgorithm = container.Resolve <IPathfindingAlgorithm>(); }
public object WeakGetObject(CryoContainer container, params object[] parameters) { if (_exist) { return(_instance); } return(null); }
public void ExternalInGlobal() { var container = new CryoContainer { LifetimeErrorReaction = Reaction.ThrowException }; container.RegisterSingleton <MySingleton>(LifeTime.External); container.RegisterType <MyInstance>(LifeTime.Global); container.Resolve <MyInstance>(); }
public void SceneInExternal() { var container = new CryoContainer { OnLifetimeError = Reaction.ThrowException }; container.RegisterSingleton <MySingleton>(LifeTime.Scene); container.RegisterType <MyInstance>(LifeTime.External); container.Resolve <MyInstance>(); }
public object GetObject(CryoContainer container, params object[] parameters) { if (!_exist) { _instance = _factoryMethod(); _exist = true; container.BuildUp(_instance, parameters); LifeTimeManager.TryToAdd(this, LifeTime); } return(_instance); }
public object GetObject(object owner, CryoContainer container, params object[] parameters) { var obj = _factoryMethod(); container.BuildUp(obj, parameters); if (obj is IDisposable disposable) { _lifeTimeManager.Add(disposable, LifeTime); } return(obj); }
public void TestType() { var container = new CryoContainer(); container.RegisterType <MyClazz>(); Assert.IsNull(container.TryResolve <MyClazz>()); var clazz = container.Resolve <MyClazz>(); Assert.IsNotNull(clazz); Assert.IsNull(container.TryResolve <MyClazz>()); }
public void TestInstance() { var container = new CryoContainer(); var myClazz = new MyClazz(); container.RegisterInstance(myClazz); var myClazz2 = container.TryResolve <MyClazz>(); Assert.IsNotNull(myClazz2); Assert.AreSame(myClazz, myClazz2); }
public void LongChain() { var container = new CryoContainer { CircularDependencyReaction = Reaction.LogWarning }; container.RegisterSingleton <Class1>(); container.RegisterSingleton <Class2>(); container.RegisterSingleton <Class3>(); container.RegisterSingleton <Class4>(); container.Resolve <Class2>(); }
public void TestSimplePropertiesBuildup() { var container = new CryoContainer(); container.RegisterInstance("private base", "PrivateBase"); container.RegisterInstance("protected base", "ProtectedBase"); container.RegisterInstance("public base", "PublicBase"); var a = new ClassBase(); container.BuildUp(a); a.Check(); }
public void TestBuildUpSimilarParams() { var container = new CryoContainer(); var val = new ClassWithSimilarParams(); container.BuildUp(val, new Param { Name = "Two", Value = 2 }, "Hello, world!", new Param("One", 1)); Assert.AreEqual(1, val.One); Assert.AreEqual(2, val.Two); Assert.AreEqual("Hello, world!", val.Str); }
public void TestSimplePropertiesResolve() { var container = new CryoContainer(); container.RegisterInstance("private base", "PrivateBase"); container.RegisterInstance("protected base", "ProtectedBase"); container.RegisterInstance("public base", "PublicBase"); container.RegisterType <ClassBase>(); var a = container.Resolve <ClassBase>(); a.Check(); }
public void InitializeCalled() { var container = new CryoContainer { CircularDependencyReaction = Reaction.LogWarning }; container.RegisterSingleton <ClassA>(); container.RegisterSingleton <ClassB>(); var a = container.Resolve <ClassA>(); Assert.IsTrue(a.InitializeCalled); Assert.IsTrue(a.ClassB.InitializeCalled); }
public void TestBuildUpFailed() { var container = new CryoContainer(); try { var val = new ClassWithParams(); container.BuildUp(val); Assert.Fail("Expected exception not happened"); } catch (ContainerException) { } }
public void TestResolveSimilarParams() { var container = new CryoContainer(); container.RegisterType <ClassWithSimilarParams>(); var val = container.Resolve <ClassWithSimilarParams>(new Param { Name = "Two", Value = 2 }, "Hello, world!", new Param("One", 1)); Assert.AreEqual(1, val.One); Assert.AreEqual(2, val.Two); Assert.AreEqual("Hello, world!", val.Str); }
private static void CreateContainer() { _container = new CryoContainer(); _container.RegisterSingleton <SingletonCounter>(GlobalSingleton, LifeTime.Global); _container.RegisterSingleton <SingletonCounter>(SceneSingleton, LifeTime.Scene); _container.RegisterSingleton <SingletonCounter>(ExternalSingleton, LifeTime.External); _container.RegisterType <TypeCounter>(GlobalType, LifeTime.Global); _container.RegisterType <TypeCounter>(SceneType, LifeTime.Scene); _container.RegisterType <TypeCounter>(ExternalType, LifeTime.External); _container.RegisterInstance(new InstanceCounter(), GlobalInstance, LifeTime.Global); _container.RegisterInstance(new InstanceCounter(), SceneInstance, LifeTime.Scene); _container.RegisterInstance(new InstanceCounter(), ExternalInstance, LifeTime.External); }
public void TestSingleton() { var container = new CryoContainer(); container.RegisterSingleton <MainClass>(); container.RegisterAlias <IFirstInterface, MainClass>(); container.RegisterAlias <ISecondInterface, MainClass>(); var firstInterface = container.Resolve <IFirstInterface>(); var secondInterface = container.Resolve <ISecondInterface>(); var mainClass = container.Resolve <MainClass>(); Assert.AreSame(mainClass, firstInterface); Assert.AreSame(mainClass, secondInterface); }
public void TestResolveFailed() { var container = new CryoContainer(); container.RegisterType <ClassWithParams>(); try { container.Resolve <ClassWithParams>(); Assert.Fail("Expected exception not happened"); } catch (ContainerException) { } }
public void TestResolveSimilarParamsFailed2() { var container = new CryoContainer(); container.RegisterType <ClassWithSimilarParams>(); try { container.Resolve <ClassWithSimilarParams>(1, "Hello, world!", 2); Assert.Fail("Expected exception not happened"); } catch (ContainerException) { } }
protected override void SetupContainer(CryoContainer container) { base.SetupContainer(container); var colorDatabase = ColorDatabaseLoader.LoadDatabase(); container.RegisterInstance <IColorDatabase>(colorDatabase, LifeTime.Global); container.RegisterSingleton <IPathfindingAlgorithm, AstarAlgorithm>(LifeTime.Scene); container.RegisterSingleton <IErrorMessageFactory, ErrorMessageFactory>(LifeTime.Global); container.RegisterSingleton <IErrorMessageController, ErrorMessageController>(LifeTime.Global); container.RegisterSceneObject <UIGridView>(LifeTime.Scene); }
public void TestBuildUpSimilarParamsFailed2() { var container = new CryoContainer(); var val = new ClassWithSimilarParams(); try { container.BuildUp(val, 1, "Hello, world!", 2); Assert.Fail("Expected exception not happened"); } catch (ContainerException) { } }
public void RefResolved() { var container = new CryoContainer { CircularDependencyReaction = Reaction.LogWarning }; container.RegisterSingleton <ClassA>(); container.RegisterSingleton <ClassB>(); var a = container.Resolve <ClassA>(); Assert.IsNotNull(a); Assert.IsNotNull(a.ClassB); Assert.IsNotNull(a.ClassB.ClassA); Assert.AreSame(a, a.ClassB.ClassA); }
public void ContainerDrained(CryoContainer container) { microGame.mechanic.loseCondition.AddAmt(1); ChangeContainers(false); }