public void TestBasicSuccess() { var container = new DiContainer(); container.Bind<IFoo>().ToSingle<Foo>(); container.Bind<Bar>().ToSingle(); Assert.That(container.ValidateResolve<IFoo>().IsEmpty()); }
public void InstallFoo(DiContainer subContainer) { NumInstalls++; subContainer.Bind<FooKernel>().AsSingle(); subContainer.Bind<IInitializable>().To<InitTest>().AsSingle(); subContainer.Bind<ITickable>().To<TickTest>().AsSingle(); subContainer.Bind<IDisposable>().To<DisposeTest>().AsSingle(); }
public void TestList() { var container = new DiContainer(); container.Bind<IFoo>().ToSingle<Foo>(); container.Bind<IFoo>().ToSingle<Foo2>(); container.Bind<Bar>().ToSingle(); container.Bind<Qux>().ToSingle(); Assert.That(container.ValidateResolve<Qux>().IsEmpty()); }
public void Test1() { NumInstalls = 0; InitTest.WasRun = false; TickTest.WasRun = false; DisposeTest.WasRun = false; var container = new DiContainer(); container.Bind(typeof(TickableManager), typeof(InitializableManager), typeof(DisposableManager)) .ToSelf().AsSingle().InheritInSubContainers(); // This is how you add ITickables / etc. within sub containers container.BindAllInterfacesAndSelf<FooKernel>() .To<FooKernel>().FromSubContainerResolve().ByMethod(InstallFoo).AsSingle(); var tickManager = container.Resolve<TickableManager>(); var initManager = container.Resolve<InitializableManager>(); var disposeManager = container.Resolve<DisposableManager>(); Assert.That(!InitTest.WasRun); Assert.That(!TickTest.WasRun); Assert.That(!DisposeTest.WasRun); initManager.Initialize(); tickManager.Update(); disposeManager.Dispose(); Assert.That(InitTest.WasRun); Assert.That(TickTest.WasRun); Assert.That(DisposeTest.WasRun); }
public static DiContainer CreateContainer(bool allowNullBindings, GlobalCompositionRoot root) { Assert.That(allowNullBindings || root != null); var container = new DiContainer(root == null ? null : root.transform); container.AllowNullBindings = allowNullBindings; container.Bind<GlobalCompositionRoot>().ToInstance(root); container.Bind<CompositionRoot>().ToInstance(root); container.Install<StandardInstaller>(); container.Install(GetGlobalInstallers()); return container; }
public void TestValidateDynamicSuccess() { var container = new DiContainer(); container.Bind<Foo>().ToSingle(); Assert.That(container.ValidateObjectGraph<Foo>(typeof(Bar)).IsEmpty()); }
public void TestValidateDynamicFailure2() { var container = new DiContainer(); container.Bind<Foo>().ToSingle(); Assert.That(!container.ValidateObjectGraph<Foo>(typeof(Bar), typeof(string)).IsEmpty()); }
public static SignalBinderWithId DeclareSignal <T>(this DiContainer container) where T : ISignalBase { var info = new BindInfo(typeof(T)); var signalSettings = new SignalSettings(); container.Bind <T>(info).AsCached().WithArguments(signalSettings, info); return(new SignalBinderWithId(info, signalSettings)); }
public static void BindLateTickableExecutionOrder( this DiContainer container, Type type, int order) { Assert.That(type.DerivesFrom <ILateTickable>(), "Expected type '{0}' to derive from ILateTickable", type); container.Bind <ModestTree.Util.ValuePair <Type, int> >().WithId("Late") .FromInstance(ModestTree.Util.ValuePair.New(type, order)).WhenInjectedInto <TickableManager>(); }
public virtual void OnEnable() { _container = new DiContainer(StaticContext.Container); // Make sure we don't create any game objects since editor windows don't have a scene _container.AssertOnNewGameObjects = true; _container.Bind<TickableManager>().AsSingle(); _container.Bind<InitializableManager>().AsSingle(); _container.Bind<DisposableManager>().AsSingle(); _container.Bind<GuiRenderableManager>().AsSingle(); InstallBindings(); _container.Inject(this); _initializableManager.Initialize(); }
public void TestBindAllInterfacesSimple() { var container = new DiContainer(); container.Bind(x => x.AllInterfaces()).To<Foo>(); Assert.That(container.Resolve<IFoo>() is Foo); Assert.That(container.Resolve<IBar>() is Foo); }
public static void BindPriority( DiContainer container, Type disposableType, int priorityCount) { Assert.That(disposableType.DerivesFrom <IDisposable>(), "Expected type '{0}' to derive from IDisposable", disposableType.Name()); container.Bind <Tuple <Type, int> >().To( Tuple.New(disposableType, priorityCount)).WhenInjectedInto <DisposableManager>(); }
public static void BindPriority( DiContainer container, Type tickableType, int priorityCount) { Assert.That(tickableType.DerivesFrom<IFixedTickable>(), "Expected type '{0}' to derive from IFixedTickable", tickableType.Name()); container.Bind<ModestTree.Util.Tuple<Type, int>>("Fixed").ToInstance( ModestTree.Util.Tuple.New(tickableType, priorityCount)).WhenInjectedInto<TickableManager>(); }
public static void BindPriority( DiContainer container, Type tickableType, int priorityCount) { Assert.That(tickableType.DerivesFrom <ILateTickable>(), "Expected type '{0}' to derive from ILateTickable", tickableType.Name()); container.Bind <ModestTree.Util.Tuple <Type, int> >("Late").ToInstance( ModestTree.Util.Tuple.New(tickableType, priorityCount)).WhenInjectedInto <TickableManager>(); }
void InstallBindings(List <MonoBehaviour> injectableMonoBehaviours) { _container.Bind(typeof(Context), typeof(SceneContext)).To <SceneContext>().FromInstance(this); foreach (var decoratorContext in _decoratorContexts) { decoratorContext.InstallDecoratorSceneBindings(); } InstallSceneBindings(injectableMonoBehaviours); _container.Bind(typeof(SceneKernel), typeof(MonoKernel)) .To <SceneKernel>().FromNewComponentOn(this.gameObject).AsSingle().NonLazy(); _container.Bind <ZenjectSceneLoader>().AsSingle(); if (ExtraBindingsInstallMethod != null) { ExtraBindingsInstallMethod(_container); // Reset extra bindings for next time we change scenes ExtraBindingsInstallMethod = null; } // Always install the installers last so they can be injected with // everything above foreach (var decoratorContext in _decoratorContexts) { decoratorContext.InstallDecoratorInstallers(); } InstallInstallers(); foreach (var decoratorContext in _decoratorContexts) { decoratorContext.InstallLateDecoratorInstallers(); } if (ExtraBindingsLateInstallMethod != null) { ExtraBindingsLateInstallMethod(_container); // Reset extra bindings for next time we change scenes ExtraBindingsLateInstallMethod = null; } }
void InstallBindings(List <MonoBehaviour> injectableMonoBehaviours) { _container.DefaultParent = this.transform; _container.Settings = _settings ?? ZenjectSettings.Default; _container.Bind <ZenjectSceneLoader>().AsSingle(); StandardInterfacesRootInstaller.Install(_container); _container.Bind <Context>().FromInstance(this); _container.Bind(typeof(ProjectKernel), typeof(MonoKernel)) .To <ProjectKernel>().FromNewComponentOn(this.gameObject).AsSingle().NonLazy(); _container.Bind <SceneContextRegistry>().AsSingle(); InstallSceneBindings(injectableMonoBehaviours); InstallInstallers(); }
public static void BindPriority( DiContainer container, Type tickableType, int priorityCount) { Assert.That(tickableType.DerivesFrom <IFixedTickable>(), "Expected type '{0}' to derive from IFixedTickable", tickableType.Name()); container.Bind <Tuple <Type, int> >().To( Tuple.New(tickableType, priorityCount)).WhenInjectedInto <TickableManager>() .As("Fixed"); }
public static void ApplyBindSettings( SubContainerCreatorBindInfo subContainerBindInfo, DiContainer subContainer) { if (subContainerBindInfo.DefaultParentName != null) { #if !ZEN_TESTS_OUTSIDE_UNITY && !NOT_UNITY3D var defaultParent = new GameObject( subContainerBindInfo.DefaultParentName); defaultParent.transform.SetParent( subContainer.InheritedDefaultParent, false); subContainer.DefaultParent = defaultParent.transform; subContainer.Bind <IDisposable>() .To <DefaultParentObjectDestroyer>().AsCached().WithArguments(defaultParent); // Always destroy the default parent last so that the non-monobehaviours get a chance // to clean it up if they want to first subContainer.BindDisposableExecutionOrder <DefaultParentObjectDestroyer>(int.MinValue); #endif } if (subContainerBindInfo.CreateKernel) { var parentContainer = subContainer.ParentContainers.OnlyOrDefault(); Assert.IsNotNull(parentContainer, "Could not find unique container when using WithKernel!"); if (subContainerBindInfo.KernelType != null) { parentContainer.Bind(typeof(Kernel).Interfaces()).To(subContainerBindInfo.KernelType) .FromSubContainerResolve() .ByInstance(subContainer).AsCached(); subContainer.Bind(subContainerBindInfo.KernelType).AsCached(); } else { parentContainer.BindInterfacesTo <Kernel>().FromSubContainerResolve() .ByInstance(subContainer).AsCached(); subContainer.Bind <Kernel>().AsCached(); } } }
public void TestLocal1() { var rootContainer = new DiContainer(); var sub1 = rootContainer.CreateSubContainer(); rootContainer.Bind<Test0>().AsSingle(); sub1.Bind<Test1>().AsSingle(); Assert.Throws(() => sub1.Resolve<Test1>()); }
public void TestAny() { var rootContainer = new DiContainer(); var sub1 = rootContainer.CreateSubContainer(); rootContainer.Bind<Test0>().AsSingle(); sub1.Bind<Test4>().AsSingle(); Assert.IsNotNull(sub1.Resolve<Test4>()); }
public void TestBindAllInterfaces2() { var container = new DiContainer(); container.Bind(x => x.AllInterfaces()) .To(x => x.AllNonAbstractClasses().InNamespace("Zenject.Tests.Convention.Two")); Assert.IsEqual(container.ResolveAll<IFoo>().Count, 2); Assert.IsEqual(container.ResolveAll<IBar>().Count, 2); }
void InstallBindings(List <MonoBehaviour> injectableMonoBehaviours) { _container.DefaultParent = transform; _container.Bind <Context>().FromInstance(this); _container.Bind <GameObjectContext>().FromInstance(this); if (_kernel == null) { _container.Bind <MonoKernel>() .To <DefaultGameObjectKernel>().FromNewComponentOn(gameObject).AsSingle().NonLazy(); } else { _container.Bind <MonoKernel>().FromInstance(_kernel).AsSingle().NonLazy(); } InstallInstallers(); }
public void TestLocal1() { var rootContainer = new DiContainer(); var sub1 = rootContainer.CreateSubContainer(); rootContainer.Bind<Test0>().ToSingle(); sub1.Bind<Test1>().ToSingle(); Assert.Throws<ZenjectResolveException>(() => sub1.Resolve<Test1>()); Assert.That(sub1.ValidateResolve<Test1>().Any()); }
void InstallBindings() { _container.DefaultParent = this.transform; _container.Bind <Context>().FromInstance(this); _container.Bind <GameObjectContext>().FromInstance(this); if (_kernel == null) { _container.Bind <MonoKernel>() .To <DefaultGameObjectKernel>().FromNewComponentOn(this.gameObject).AsSingle().NonLazy(); } else { _container.Bind <MonoKernel>().FromInstance(_kernel).AsSingle().NonLazy(); } InstallSceneBindings(); InstallInstallers(); }
public void Test1() { DiContainer parentContainer = new DiContainer(); parentContainer.Bind<Foo>().ToTransient(); // ToTransient should always use the DiContainer given by the inject context var subContainer = parentContainer.CreateSubContainer(); subContainer.Bind<int>().ToInstance<int>(5); var foo = subContainer.Resolve<Foo>(); Assert.AreEqual(foo.Value, 5); }
public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignal <TSignal>(this DiContainer container) { var signalBindInfo = CreateDefaultSignalDeclarationBindInfo(container, typeof(TSignal)); var bindInfo = container.Bind <SignalDeclaration>().AsCached() .WithArguments(signalBindInfo).WhenInjectedInto(typeof(SignalBus), typeof(SignalDeclarationAsyncInitializer)).BindInfo; var signalBinder = new DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder(signalBindInfo); signalBinder.AddCopyBindInfo(bindInfo); return(signalBinder); }
public static DeclareSignalRequireHandlerAsyncCopyBinder DeclareSignal <TSignal>(this DiContainer container) { var signalBindInfo = new SignalDeclarationBindInfo(typeof(TSignal)); signalBindInfo.RunAsync = container.Settings.Signals.DefaultSyncMode == SignalDefaultSyncModes.Asynchronous; signalBindInfo.MissingHandlerResponse = container.Settings.Signals.MissingHandlerDefaultResponse; var bindInfo = new BindInfo(); container.Bind <SignalDeclarationBindInfo>(bindInfo) .FromInstance(signalBindInfo).WhenInjectedInto <SignalBus>(); return(new DeclareSignalRequireHandlerAsyncCopyBinder(signalBindInfo, bindInfo)); }
public DiContainer CreateContainer( bool isValidating, DiContainer parentContainer, List <IInstaller> extraInstallers) { var container = new DiContainer(this.transform, parentContainer); container.IsValidating = isValidating; container.Bind <SceneCompositionRoot>().ToInstance(this); container.Bind <CompositionRoot>().ToInstance(this); if (BeforeInstallHooks != null) { BeforeInstallHooks(container); // Reset extra bindings for next time we change scenes BeforeInstallHooks = null; } container.Install <StandardInstaller>(); var allInstallers = extraInstallers.Concat(Installers).ToList(); if (allInstallers.Where(x => x != null).IsEmpty()) { Log.Warn("No installers found while initializing SceneCompositionRoot"); } else { container.Install(allInstallers); } if (AfterInstallHooks != null) { AfterInstallHooks(container); // Reset extra bindings for next time we change scenes AfterInstallHooks = null; } return(container); }
protected virtual void Initialize() { Assert.IsNull(_container); _container = new DiContainer(new[] { StaticContext.Container }); // Make sure we don't create any game objects since editor windows don't have a scene _container.AssertOnNewGameObjects = true; ZenjectManagersInstaller.Install(_container); _container.Bind <Kernel>().AsSingle(); _container.Bind <GuiRenderableManager>().AsSingle(); _container.BindInstance(this); InstallBindings(); _container.QueueForInject(this); _container.ResolveRoots(); _kernel.Initialize(); }
public static DiContainer CreateContainer(bool isValidating, GlobalCompositionRoot root) { Assert.That(isValidating || root != null); var container = new DiContainer(); container.IsValidating = isValidating; if (root != null) { container.Bind <Transform>(ZenConstants.DefaultParentId) .ToInstance <Transform>(root.gameObject.transform); } container.Bind <CompositionRoot>().ToInstance(root); container.Bind <GlobalCompositionRoot>().ToInstance(root); container.Install <StandardInstaller>(); container.Install(GetGlobalInstallers()); return(container); }
public DiContainer CreateContainer( bool allowNullBindings, DiContainer parentContainer, List <IInstaller> extraInstallers) { var container = new DiContainer(this.transform); container.AllowNullBindings = allowNullBindings; container.FallbackProvider = new DiContainerProvider(parentContainer); container.Bind <SceneCompositionRoot>().ToInstance(this); container.Bind <CompositionRoot>().ToInstance(this); if (BeforeInstallHooks != null) { BeforeInstallHooks(container); // Reset extra bindings for next time we change scenes BeforeInstallHooks = null; } container.Install <StandardUnityInstaller>(); var allInstallers = extraInstallers.Concat(Installers).ToList(); if (allInstallers.Where(x => x != null).IsEmpty()) { Log.Warn("No installers found while initializing SceneCompositionRoot"); } else { CompositionRootHelper.InstallSceneInstallers(container, allInstallers); } if (AfterInstallHooks != null) { AfterInstallHooks(container); // Reset extra bindings for next time we change scenes AfterInstallHooks = null; } return(container); }
public SignalCopyBinder ToMethod(Action <TSignal> callback) { Assert.IsNull(_finalizerWrapper.SubFinalizer); _finalizerWrapper.SubFinalizer = new NullBindingFinalizer(); var bindInfo = _container.Bind <IDisposable>() .To <SignalCallbackWrapper <TSignal> >() .AsCached() .WithArguments(callback) .NonLazy().BindInfo; return(new SignalCopyBinder(bindInfo)); }
void InstallBindings(List <MonoBehaviour> injectableMonoBehaviours) { _container.DefaultParent = this.transform; // Note that adding GuiRenderableManager here doesn't instantiate it by default // You still have to add GuiRenderer manually // We could add the contents of GuiRenderer into MonoKernel, but this adds // undesirable per-frame allocations. See comment in IGuiRenderable.cs for usage // // Short answer is if you want to use IGuiRenderable then // you need to include the following in project context installer: // `Container.Bind<GuiRenderer>().FromNewComponentOnNewGameObject().AsSingle().CopyIntoAllSubContainers().NonLazy();` _container.Bind(typeof(TickableManager), typeof(InitializableManager), typeof(DisposableManager), typeof(GuiRenderableManager)) .ToSelf().AsSingle().CopyIntoAllSubContainers(); _container.Bind <SignalManager>().AsSingle(); _container.Bind <Context>().FromInstance(this); _container.Bind <ProjectKernel>().FromNewComponentOn(this.gameObject).AsSingle().NonLazy(); InstallSceneBindings(injectableMonoBehaviours); InstallInstallers(); }
public void RebindingInSubContainer() { DiContainer parentContainer = new DiContainer(); parentContainer.Bind<IHaveMessage>().ToSingle<Welcome>(); Assert.AreEqual("Welcome", parentContainer.Resolve<IHaveMessage>().GetMessage()); DiContainer childContainer = parentContainer.CreateSubContainer(); childContainer.Rebind<IHaveMessage>().ToSingle<Bye>(); Assert.AreEqual("Bye", childContainer.Resolve<IHaveMessage>().GetMessage()); Assert.AreEqual("Welcome", parentContainer.Resolve<IHaveMessage>().GetMessage()); }
void InstallBindings(InitialComponentsInjecter componentInjecter) { if (_parentNewObjectsUnderRoot) { _container.DefaultParent = this.transform; } else { // This is necessary otherwise we inherit the project root DefaultParent _container.DefaultParent = null; } _container.Bind <Context>().FromInstance(this); _container.Bind <SceneContext>().FromInstance(this); InstallSceneBindings(componentInjecter); if (BeforeInstallHooks != null) { BeforeInstallHooks(_container); // Reset extra bindings for next time we change scenes BeforeInstallHooks = null; } _container.Bind <SceneKernel>().FromComponent(this.gameObject).AsSingle().NonLazy(); _container.Bind <ZenjectSceneLoader>().AsSingle(); InstallInstallers(); if (AfterInstallHooks != null) { AfterInstallHooks(_container); // Reset extra bindings for next time we change scenes AfterInstallHooks = null; } }
public static void BindPriority( DiContainer container, Type type, int priority) { Assert.That(type.DerivesFrom <ITickable>() || type.DerivesFrom <IInitializable>() || type.DerivesFrom <IDisposable>(), "Expected type '{0}' to derive from ITickable, IInitializable, or IDisposable", type.Name()); if (type.DerivesFrom <ITickable>()) { container.Bind <ModestTree.Util.Tuple <Type, int> >().ToInstance( ModestTree.Util.Tuple.New(type, priority)).WhenInjectedInto <TickableManager>(); } if (type.DerivesFrom <IInitializable>()) { container.Bind <ModestTree.Util.Tuple <Type, int> >().ToInstance( ModestTree.Util.Tuple.New(type, priority)).WhenInjectedInto <InitializableManager>(); } if (type.DerivesFrom <IDisposable>()) { container.Bind <ModestTree.Util.Tuple <Type, int> >().ToInstance( ModestTree.Util.Tuple.New(type, priority)).WhenInjectedInto <DisposableManager>(); } }
public static DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder DeclareSignal <TSignal>(this DiContainer container) { var signalBindInfo = new SignalDeclarationBindInfo(typeof(TSignal)); signalBindInfo.RunAsync = container.Settings.Signals.DefaultSyncMode == SignalDefaultSyncModes.Asynchronous; signalBindInfo.MissingHandlerResponse = container.Settings.Signals.MissingHandlerDefaultResponse; signalBindInfo.TickPriority = container.Settings.Signals.DefaultAsyncTickPriority; var bindInfo = container.Bind <SignalDeclaration>().AsCached() .WithArguments(typeof(TSignal), signalBindInfo).WhenInjectedInto(typeof(SignalBus), typeof(SignalDeclarationAsyncInitializer)).BindInfo; var signalBinder = new DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder(signalBindInfo); signalBinder.AddCopyBindInfo(bindInfo); return(signalBinder); }
public SignalCopyBinder ToMethod(Action <TSignal> callback) { Assert.IsNull(_finalizerWrapper.SubFinalizer); _finalizerWrapper.SubFinalizer = new NullBindingFinalizer(); var bindInfo = _container.Bind <IDisposable>() .To <SignalCallbackWrapper>() .AsCached() // Note that there's a reason we don't just make SignalCallbackWrapper have a generic // argument for signal type - because when using struct type signals it throws // exceptions on AOT platforms .WithArguments(typeof(TSignal), (Action <object>)((o) => callback((TSignal)o))) .NonLazy().BindInfo; return(new SignalCopyBinder(bindInfo)); }
public static BindingConditionSetter BindGameObjectFactory <T>( this DiContainer container, GameObject prefab) // This would be useful but fails with VerificationException's in webplayer builds for some reason //where T : GameObjectFactory where T : class { if (prefab == null) { throw new ZenjectBindException( "Null prefab provided to BindGameObjectFactory for type '{0}'".Fmt(typeof(T).Name())); } // We could bind the factory ToSingle but doing it this way is better // since it allows us to have multiple game object factories that // use different prefabs and have them injected into different places return(container.Bind <T>().ToMethod((ctx) => ctx.Container.Instantiate <T>(prefab))); }
public void RebindingInSubContainer2() { DiContainer parentContainer = new DiContainer(); parentContainer.Bind<IHaveMessage>().ToSingle<Welcome>(); Assert.AreEqual("Welcome", parentContainer.Resolve<IHaveMessage>().GetMessage()); DiContainer childContainer = parentContainer.CreateSubContainer(); User user = new User(); childContainer.Inject(user); Assert.AreEqual("Welcome", user.SayIt()); user.Rebind(); Assert.AreEqual("Bye", user.SayIt()); parentContainer.Inject(user); Assert.AreEqual("Welcome", user.SayIt()); }
public void TestCase1() { var container1 = new DiContainer(); Assert.Throws<ZenjectResolveException>(() => container1.Resolve<IFoo>()); Assert.Throws<ZenjectResolveException>(() => Container.Resolve<IFoo>()); Container.Bind<IFoo>().ToSingle<Foo>(); Assert.Throws<ZenjectResolveException>(() => container1.Resolve<IFoo>()); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); var container2 = new DiContainer(Container); Assert.IsEqual(container2.Resolve<IFoo>().GetBar(), 0); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); container2.Bind<IFoo>().ToSingle<Foo2>(); Assert.IsEqual(container2.Resolve<IFoo>().GetBar(), 1); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); }
public void TestCase1() { var nestedContainer = new DiContainer(); Assert.Throws<ZenjectResolveException>(() => nestedContainer.Resolve<IFoo>()); Assert.Throws<ZenjectResolveException>(() => Container.Resolve<IFoo>()); Container.Bind<IFoo>().ToSingle<Foo>(); Assert.Throws<ZenjectResolveException>(() => nestedContainer.Resolve<IFoo>()); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); nestedContainer.FallbackProvider = new DiContainerProvider(Container); Assert.IsEqual(nestedContainer.Resolve<IFoo>().GetBar(), 0); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); nestedContainer.Bind<IFoo>().ToSingle<Foo2>(); Assert.IsEqual(nestedContainer.Resolve<IFoo>().GetBar(), 1); Assert.IsEqual(Container.Resolve<IFoo>().GetBar(), 0); }
DiContainer CreateTempContainer(List <TypeValuePair> args) { DiContainer tempSubContainer = Container.CreateSubContainer(); ZenjectTypeInfo installerInjectables = TypeAnalyzer.GetInfo(_installerType); foreach (TypeValuePair argPair in args) { // We need to intelligently match on the exact parameters here to avoid the issue // brought up in github issue #217 InjectableInfo match = installerInjectables.AllInjectables .Where(x => argPair.Type.DerivesFromOrEqual(x.MemberType)) .OrderBy(x => ZenUtilInternal.GetInheritanceDelta(argPair.Type, x.MemberType)).FirstOrDefault(); Assert.That(match != null, "Could not find match for argument type '{0}' when injecting into sub container installer '{1}'", argPair.Type, _installerType); tempSubContainer.Bind(match.MemberType) .FromInstance(argPair.Value).WhenInjectedInto(_installerType); } return(tempSubContainer); }
public SignalCopyBinder From(Action <ConcreteBinderGeneric <TObject> > objectBindCallback) { Assert.IsNull(_finalizerWrapper.SubFinalizer); _finalizerWrapper.SubFinalizer = new NullBindingFinalizer(); var objectLookupId = Guid.NewGuid(); // Very important here that we use NoFlush otherwise the main binding will be finalized early var objectBinder = _container.BindNoFlush <TObject>().WithId(objectLookupId); objectBindCallback(objectBinder); var wrapperBinder = _container.Bind <IDisposable>() .To <SignalCallbackWithLookupWrapper <TObject, TSignal> >() .AsCached() .WithArguments(_methodGetter, objectLookupId) .NonLazy(); var copyBinder = new SignalCopyBinder(wrapperBinder.BindInfo); // Make sure if they use one of the Copy/Move methods that it applies to both bindings copyBinder.AddCopyBindInfo(objectBinder.BindInfo); return(copyBinder); }
public void TestValidateNestedContainerSuccess() { var container = new DiContainer(); var nestedContainer = new DiContainer(container); // Should fail without Bar<> bound Assert.That(!nestedContainer.ValidateObjectGraph<Foo>().IsEmpty()); container.Bind<Bar>().ToSingle(); Assert.That(nestedContainer.ValidateObjectGraph<Foo>().IsEmpty()); }
public void TestParentAny1() { var rootContainer = new DiContainer(); var sub1 = rootContainer.CreateSubContainer(); var sub2 = sub1.CreateSubContainer(); rootContainer.Bind<Test0>().ToSingle(); sub2.Bind<Test3>().ToSingle(); Assert.IsNotNull(sub2.Resolve<Test3>()); Assert.That(sub2.ValidateResolve<Test3>().IsEmpty()); }
public DiContainer CreateContainer( bool allowNullBindings, DiContainer parentContainer, List<IInstaller> extraInstallers) { var container = new DiContainer(this.transform); container.AllowNullBindings = allowNullBindings; container.FallbackProvider = new DiContainerProvider(parentContainer); container.Bind<CompositionRoot>().ToInstance(this); if (BeforeInstallHooks != null) { BeforeInstallHooks(container); // Reset extra bindings for next time we change scenes BeforeInstallHooks = null; } CompositionRootHelper.InstallStandardInstaller(container, this.gameObject); var allInstallers = extraInstallers.Concat(Installers).ToList(); if (allInstallers.Where(x => x != null).IsEmpty()) { Log.Warn("No installers found while initializing CompositionRoot"); } else { CompositionRootHelper.InstallSceneInstallers(container, allInstallers); } if (AfterInstallHooks != null) { AfterInstallHooks(container); // Reset extra bindings for next time we change scenes AfterInstallHooks = null; } return container; }
public void TestParent2() { var rootContainer = new DiContainer(); var sub1 = rootContainer.CreateSubContainer(); var sub2 = sub1.CreateSubContainer(); rootContainer.Bind<Test0>().AsSingle(); sub2.Bind<Test2>().AsSingle(); Assert.Throws(() => sub2.Resolve<Test2>()); }
public void TestParent3() { var rootContainer = new DiContainer(); rootContainer.Bind<Test0>().AsSingle(); rootContainer.Bind<Test2>().AsSingle(); Assert.Throws(() => rootContainer.Resolve<Test2>()); }
public void TestValidateNestedContainerList() { var container = new DiContainer(); var nestedContainer = new DiContainer(container); container.Bind<IFoo>().ToSingle<Foo>(); container.Bind<IFoo>().ToSingle<Foo2>(); Assert.That(!container.ValidateResolve<List<IFoo>>().IsEmpty()); Assert.That(!nestedContainer.ValidateResolve<List<IFoo>>().IsEmpty()); container.Bind<Bar>().ToSingle(); Assert.That(container.ValidateResolve<List<IFoo>>().IsEmpty()); // Should not throw nestedContainer.Resolve<List<IFoo>>(); Assert.That(nestedContainer.ValidateResolve<List<IFoo>>().IsEmpty()); }
public void TestParent3() { var rootContainer = new DiContainer(); rootContainer.Bind<Test0>().ToSingle(); rootContainer.Bind<Test2>().ToSingle(); Assert.Throws<ZenjectResolveException>(() => rootContainer.Resolve<Test2>()); Assert.That(rootContainer.ValidateResolve<Test2>().Any()); }
public static void BindTickable <TTickable>(DiContainer container, int priority) where TTickable : ITickable { container.Bind <ITickable>().ToSingle <TTickable>(); BindTickablePriority <TTickable>(container, priority); }
protected static ConditionCopyNonLazyBinder AddBindingInternal <TDerived>(DiContainer container, TKey key) where TDerived : TBase { return(container.Bind <ValuePair <TKey, Type> >() .FromInstance(ValuePair.New(key, typeof(TDerived)))); }
public void InstallDecoratorSceneBindings() { _container.Bind <SceneDecoratorContext>().FromInstance(this); InstallSceneBindings(); }
void InstallFooFacade(DiContainer container) { container.Bind<Foo>().AsSingle(); container.Bind<Bar>().AsSingle(); container.Bind<Gorp>().WithId("gorp"); }
public static DiContainer CreateContainer(bool isValidating, GlobalCompositionRoot root) { Assert.That(isValidating || root != null); var container = new DiContainer(); container.IsValidating = isValidating; if (root != null) { container.Bind<Transform>(ZenConstants.DefaultParentId) .ToInstance<Transform>(root.gameObject.transform); } container.Bind<CompositionRoot>().ToInstance(root); container.Bind<GlobalCompositionRoot>().ToInstance(root); container.Install<StandardInstaller>(); container.Install(GetGlobalInstallers()); return container; }
public void InstallDecoratorSceneBindings() { _container.Bind <SceneDecoratorContext>().FromInstance(this); InstallSceneBindings(_injectableMonoBehaviours); }
public DiContainer CreateContainer( bool isValidating, DiContainer parentContainer, List<IInstaller> extraInstallers) { var container = new DiContainer(parentContainer); container.IsValidating = isValidating; container.Bind<CompositionRoot>().ToInstance(this); container.Bind<SceneCompositionRoot>().ToInstance(this); if (ParentNewObjectsUnderRoot) { container.Bind<Transform>(ZenConstants.DefaultParentId) .ToInstance<Transform>(this.transform); } if (BeforeInstallHooks != null) { BeforeInstallHooks(container); // Reset extra bindings for next time we change scenes BeforeInstallHooks = null; } container.Install<StandardInstaller>(); var allInstallers = extraInstallers.Concat(Installers).ToList(); if (allInstallers.Where(x => x != null).IsEmpty()) { Log.Warn("No installers found while initializing SceneCompositionRoot"); } else { container.Install(allInstallers); } if (AfterInstallHooks != null) { AfterInstallHooks(container); // Reset extra bindings for next time we change scenes AfterInstallHooks = null; } return container; }
public static void BindTickablePriority <TTickable>(DiContainer container, int priority) { container.Bind <Tuple <Type, int> >().To(Tuple.New(typeof(TTickable), priority)); }
public static void InstallStandardInstaller(DiContainer container, GameObject rootObj) { container.Bind<GameObject>().ToInstance(rootObj).WhenInjectedInto<StandardUnityInstaller>(); container.Install<StandardUnityInstaller>(); }