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>();
}