// Install basic functionality for most unity apps
public static void InstallUnityStandard(DiContainer container)
{
container.Bind<IKernel>().AsSingleGameObject<UnityKernel>("Kernel");
container.Bind<EntryPointInitializer>().AsSingle();
container.Bind<IEntryPoint>().AsSingle<KernelInitializer>();
container.Bind<ITickable>().AsLookup<UnityEventManager>();
}
public void RegisterBindings(DiContainer container)
{
container.Bind<ShipStateMoving.Settings>().AsSingle(settings.shipMoving);
container.Bind<ShipStateDead.Settings>().AsSingle(settings.shipDead);
container.Bind<ShipStateWaitingToStart.Settings>().AsSingle(settings.shipStarting);
container.Bind<AsteroidSpawner.Settings>().AsSingle(settings.asteroidSpawner);
container.Bind<Asteroid.Settings>().AsSingle(settings.asteroid);
}
void InitContainer()
{
_container = new DiContainer();
// Note: This has to go first
_container.Bind<CompositionRoot>().AsSingle(this);
// Init default dependencies
_container.Bind<MonoBehaviourFactory>().AsSingle();
_container.Bind<UnityEventManager>().AsSingleGameObject();
}
public override void Install(DiContainer container)
{
container.BindInstance(rawInputChecker);
container.BindInstance(mousePositionProvider);
container.BindInstance(faceTracker);
container.BindInstance(handTracker);
container.BindInstance(externalTracker);
container.BindInstance(gamepadListener);
container.BindInstance(midiInputObserver);
//終了前に監視処理を安全にストップさせたいものは呼んでおく
container.Bind <IReleaseBeforeQuit>()
.FromInstance(mousePositionProvider)
.AsCached();
container.Bind <IReleaseBeforeQuit>()
.FromInstance(rawInputChecker)
.AsCached();
}
public void Bind <TFrom, TTo>(BindingConfiguration configuration = null) where TTo : TFrom
{
var bindingSetup = _container.Bind <TFrom>();
if (configuration == null)
{
bindingSetup.To <TTo>().AsSingle();
return;
}
if (configuration.ToInstance != null)
{
var instanceBinding = bindingSetup.FromInstance((TFrom)configuration.ToInstance);
if (configuration.AsSingleton)
{
instanceBinding.AsSingle();
}
return;
}
if (configuration.ToMethod != null)
{
var methodBinding = bindingSetup.FromMethod(x => (TTo)configuration.ToMethod(this));
if (configuration.AsSingleton)
{
methodBinding.AsSingle();
}
return;
}
if (!string.IsNullOrEmpty(configuration.WithName))
{
bindingSetup.WithId(configuration.WithName);
}
var binding = bindingSetup.To <TFrom>();
if (configuration.AsSingleton)
{
binding.AsSingle();
}
if (configuration.WithNamedConstructorArgs.Count > 0)
{
binding.WithArguments(configuration.WithNamedConstructorArgs.Values);
}
if (configuration.WithTypedConstructorArgs.Count > 0)
{
var typePairs = configuration.WithTypedConstructorArgs.Select(x => new TypeValuePair(x.Key, x.Value));
binding.WithArgumentsExplicit(typePairs);
}
}
public override void Install(DiContainer container)
{
Container.Bind <IEncounterLocker>().To <EncounterLocker>().AsTransient();
Container.Bind <IEncounterUnlocker>().To <EncounterUnlocker>().AsTransient();
SignalBusInstaller.Install(container);
container.DeclareSignal <SceneChangedSignal>().OptionalSubscriber();
container.Bind <SizeManager>().To <SizeManager>().AsSingle();
container.Bind <ICurve>().To <AccelerationCurve>().AsTransient();
container.Bind <IShiftTransformsAnimator>().To <ShiftTransformsAnimator>().AsTransient();
container.BindFactory <Object, GameObject, GameObjectFactory>()
.FromFactory <PrefabFactory <GameObject> >();
container.BindFactory <Object, RectTransform, RectTransformFactory>()
.FromFactory <PrefabFactory <RectTransform> >();
}
public static void BindPriority(
DiContainer container, Type initializableType, int priorityCount)
{
Assert.That(initializableType.DerivesFrom<IInitializable>(),
"Expected type '{0}' to derive from IInitializable", initializableType.Name());
container.Bind<Tuple<Type, int>>().To(
Tuple.New(initializableType, priorityCount)).WhenInjectedInto<InitializableHandler>();
}
public void Bind(Type fromType, Type toType, BindingConfiguration configuration = null)
{
var bindingSetup = _container.Bind(fromType);
if (configuration == null)
{
bindingSetup.To(toType).AsSingle();
return;
}
if (configuration.ToInstance != null)
{
var instanceBinding = bindingSetup.FromInstance(configuration.ToInstance);
if (configuration.AsSingleton)
{
instanceBinding.AsSingle();
}
return;
}
if (configuration.ToMethod != null)
{
var methodBinding = bindingSetup.FromMethod(x => configuration.ToMethod(this));
if (configuration.AsSingleton)
{
methodBinding.AsSingle();
}
return;
}
var binding = bindingSetup.To(toType);
if (!string.IsNullOrEmpty(configuration.WithName))
{
binding.WithConcreteId(configuration.WithName);
}
if (configuration.AsSingleton)
{
binding.AsSingle();
}
if (configuration.WithNamedConstructorArgs.Count > 0)
{
binding.WithArguments(configuration.WithNamedConstructorArgs.Values);
}
if (configuration.WithTypedConstructorArgs.Count > 0)
{
var typePairs = configuration.WithTypedConstructorArgs.Select(x => new TypeValuePair(x.Key, x.Value));
binding.WithArgumentsExplicit(typePairs);
}
}
public static void BindCommandHandler <T, TH>(this DiContainer container)
where T : ICommand
where TH : ICommandHandler
{
container.Bind <ICommandHandler>()
.WithId(typeof(T))
.To <TH>()
.AsSingle();
}
public static DiContainer BindAsyncRequestHandlerFilter <T>(this DiContainer builder)
where T : class, IAsyncRequestHandlerFilter
{
if (!builder.HasBinding <T>())
{
builder.Bind <T>().AsTransient();
}
return(builder);
}
public static ScopeConcreteIdArgConditionCopyNonLazyBinder BindComponentFromProvider <TComponent, TProvider>(
this DiContainer container, object id = null)
where TComponent : Component
where TProvider : IComponentProvider <TComponent>, new()
{
return(container.Bind <TComponent>().WithId(id)
.FromResolveGetter <IComponentProvisionService>(service =>
service.Provide <TComponent>(typeof(TProvider))));
}
public static void BindPriority(
DiContainer container, Type tickableType, int priorityCount)
{
Assert.That(tickableType.DerivesFrom<ITickable>(),
"Expected type '{0}' to derive from ITickable", tickableType.Name());
container.Bind<Tuple<Type, int>>().To(
Tuple.New(tickableType, priorityCount)).WhenInjectedInto<StandardKernel>();
}
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 void TestBindAllInterfacesSimple()
{
var container = new DiContainer();
container.Bind(x => x.AllInterfaces()).To <Foo>().AsTransient();
Assert.That(container.Resolve <IFoo>() is Foo);
Assert.That(container.Resolve <IBar>() is Foo);
}
public static void BindSignalToSubscriber <TSignal, TSubscriber>(this DiContainer container)
where TSubscriber : ISignalSubscriber
where TSignal : ISignal
{
container.Bind <ISignalSubscriptionBinding>()
.To <SignalSubscriptionBinding <TSignal> >()
.FromNew()
.WhenInjectedInto <TSubscriber>();
}
public void TestBasicFailure()
{
var container = new DiContainer();
container.Bind <IFoo>().ToSingle <Foo>();
//container.Bind<Bar>().ToSingle();
TestAssert.That(!container.ValidateResolve <IFoo>().IsEmpty());
}
protected virtual void InstallEncounterWriterBindings(DiContainer subcontainer)
{
foreach (SaveType saveType in Enum.GetValues(typeof(SaveType)))
{
subcontainer.Bind <IEncounterWriter>().WithId(saveType)
.FromSubContainerResolve().ByMethod(
(container) => BindEncounterWriterInstaller(container, saveType)).AsTransient();
}
}
public void Initialize(
[Inject] DiContainer diContainer,
[Inject] DisposableManager dManager,
[Inject] TickableManager tManager,
[Inject] Service.Events.IEventsService eventService)
{
if (ViewInitialized)
{
return;
}
ViewInitialized = true;
PreBind();
Container = diContainer;
_dManager = dManager;
_tManager = tManager;
_eventService = eventService;
this.ControllerProperty.DistinctUntilChanged().Subscribe(e => ListenToControllerDispose()).AddTo(this);
//Create controller if this view is created through editor/sceneload
if (createController && Controller == null)
{
IController _c = CreateController();
_c.Bind();
SetController(_c);
}
//To make IDisposable work, we have to add this instance to the disposable manager
_dManager.Add(this);
//Make ITickable work
AddTickable(this);
//Bind all interfaces for this instance
//Container.BindAllInterfacesFromInstance(this);
Container.Bind <IView>().FromInstance(this);
Container.Bind <ITickable>().FromInstance(this);
//Debug.Log(this + " init");
AfterBind();
}
void Initialize(
[Inject] DiContainer diContainer,
[Inject] DisposableManager dManager,
[Inject] TickableManager tManager,
[Inject] IEventsService eventService)
{
if (isInitialized)
{
return;
}
isInitialized = true;
PreBind();
Container = diContainer;
_dManager = dManager;
_tManager = tManager;
_eventService = eventService;
Profiler.BeginSample("dmanager add");
//To make IDisposable work, we have to add this instance to the disposable manager
_dManager.Add(this);
Profiler.EndSample();
//Make ITickable work
Profiler.BeginSample("Add tickable");
// this takes most of the time
AddTickable(this);
Profiler.EndSample();
//Bind all interfaces for this instance
Profiler.BeginSample("ITickable fromInstance");
Container.Bind <ITickable>().FromInstance(this);
Profiler.EndSample();
Profiler.BeginSample("IDisposable fromInstance");
Container.Bind <IDisposable>().FromInstance(this);
//Container.BindAllInterfacesFromInstance(this);
Profiler.EndSample();
Profiler.BeginSample("AfterBind");
AfterBind();
Profiler.EndSample();
}
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;
}
}
public void Awake()
{
if (root == null)
{
root = this.transform;
}
this.app = this;
presentersMap = new Dictionary <string, ValuePair <IRoute, Type> >();
layoutsMap = new Dictionary <string, ValuePair <IRoute, Type> >();
container = new DiContainer();
container.Bind <IApplication>().FromInstance(this);
container.Bind <IRouter>().FromInstance(this);
SetupDI();
Configure(this, container);
}
public static void Install(DiContainer container)
{
container.BindInterfacesAndSelfTo <CustomComponentHandler>().AsSingle();
container.Bind <BaseGameUiHandler>().AsSingle();
container
.BindFactory <Type, SubView.InitData, SubView, SubView.Factory>()
.FromFactory <SubViewFactory>();
container
.BindFactory <Type, CustomViewController.InitData, CustomViewController, CustomViewController.Factory>()
.FromFactory <ViewControllerFactory>();
container
.BindFactory <CustomScreen.InitData, CustomScreen, CustomScreen.Factory>()
.FromFactory <ScreenFactory>();
container.Bind <StyleSheetHandler>().AsSingle();
container.BindInterfacesAndSelfTo <BsmlDecorator>().AsSingle();
BindUiFactory <Popup, Popup.Factory>(container);
BindUiFactory <CustomUiComponent, CustomUiComponent.Factory>(container);
}
protected override void Bind(DiContainer container)
{
container.Bind <DynamicModelContainer <DebuggableValueModel> >().ToSelf().AsCached();
container.BindFactory <IDebuggableValueViewModel, DebuggableValueView, DebuggableValueViewFactory>()
.FromMonoPoolableMemoryPool(x => x.WithInitialSize(10)
.FromComponentInNewPrefab(DebugViewPrefab)
.UnderTransformGroup(
$"{nameof(DebugViewPrefab)} parent"));
}
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 static void BindController<TController>(this DiContainer container)
// where TController : Controller
// {
// container.Bind<TController>().ToSingle();
// container.Bind<IInitializable>().ToSingle<TController>();
// container.Bind<IDisposable>().ToSingle<TController>();
// }
public static void BindViewController <TView, TController>(this DiContainer container, GameObject viewPrefab, Transform parent)
where TView : View
where TController : Controller
{
// todo bad practice
var view = container.InstantiatePrefab(viewPrefab, parent);
container.Bind <TView>().FromComponentOn(view).AsSingle();
container.BindInterfacesAndSelfTo <TController>().AsSingle();
}
public void TestValidateNestedContainerList()
{
var container = new DiContainer();
var nestedContainer = new DiContainer();
nestedContainer.FallbackProvider = new DiContainerProvider(container);
container.Bind <IFoo>().ToSingle <Foo>();
container.Bind <IFoo>().ToSingle <Foo2>();
TestAssert.That(!container.ValidateResolve <List <IFoo> >().IsEmpty());
TestAssert.That(!nestedContainer.ValidateResolve <List <IFoo> >().IsEmpty());
container.Bind <Bar>().ToSingle();
TestAssert.That(container.ValidateResolve <List <IFoo> >().IsEmpty());
TestAssert.That(nestedContainer.ValidateResolve <List <IFoo> >().IsEmpty());
}
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);
}
public void SetUp()
{
container = new DiContainer();
container.Bind <CameraCapture>().AsSingle();
cameraCaptureSystem = Substitute.For <ICameraCaptureSystem>();
container.Bind <ICameraCaptureSystem>().FromInstance(cameraCaptureSystem);
database = Substitute.For <IDatabase>();
container.Bind <IDatabase>().FromInstance(database);
photoGallery = Substitute.For <IPhotoGallery>();
container.Bind <IPhotoGallery>().FromInstance(photoGallery);
permissions = Substitute.For <IPermissions>();
container.Bind <IPermissions>().FromInstance(permissions);
container.Inject(this);
}
public void SetUp()
{
container = new DiContainer();
raycastSystem = Substitute.For <IRaycastSystem>();
container.Bind <IRaycastSystem>().FromInstance(raycastSystem).AsSingle();
aRObject = Substitute.For <IARObject>();
container.BindMemoryPool <IARObject, ARObjectPool>().FromInstance(aRObject);
aRObjectAlignment = Substitute.For <IARObjectAlignment>();
container.Bind <IARObjectAlignment>().FromInstance(aRObjectAlignment);
cameraSystem = Substitute.For <ICameraSystem>();
container.Bind <ICameraSystem>().FromInstance(cameraSystem);
container.Bind(typeof(ARObjectSpawner)).To <ARObjectSpawner>().AsSingle();
container.Inject(this);
}
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 TestParent1()
{
var rootContainer = new DiContainer();
var sub1 = rootContainer.CreateSubContainer();
rootContainer.Bind <Test0>().ToSingle();
sub1.Bind <Test2>().ToSingle();
Assert.IsNotNull(sub1.Resolve <Test2>());
Assert.That(sub1.ValidateResolve <Test2>().IsEmpty());
}
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());
}
public static void BindPoolContainer <TPoolable, PoolFactory>(this DiContainer container, GameObject[] prefabList, int[] initialPoolSizes)
where TPoolable : PoolableMonoBehaviour
where PoolFactory : PlaceholderFactory <int, TPoolable>
{
PoolablePoolContainer <TPoolable> poolContainer = new PoolablePoolContainer <TPoolable>(prefabList, container, initialPoolSizes);
container.BindFactory <int, TPoolable, PoolFactory>()
.FromMethod((cont, index) => poolContainer.SpawnFromPool(index));
container.Bind <IInitializable>().To <PoolablePoolContainer <TPoolable> >().FromInstance(poolContainer);
}
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();
}
InstallSceneBindings(injectableMonoBehaviours);
InstallInstallers();
}
void InitContainer()
{
_container = new DiContainer();
// Note: This has to go first
_container.Bind<CompositionRoot>().To(this);
if (_extraBindingLookup != null)
{
_extraBindingLookup(_container);
_extraBindingLookup = null;
}
}
static IEnumerable<ZenjectResolveException> ValidateInstallers(CompositionRoot compRoot)
{
var container = new DiContainer();
container.Bind<CompositionRoot>().ToSingle(compRoot);
var allInstallers = new List<IInstaller>();
foreach (var installer in compRoot.Installers)
{
if (installer == null)
{
yield return new ZenjectResolveException(
"Found null installer in properties of Composition Root");
yield break;
}
if (installer.enabled)
{
installer.Container = container;
container.Bind<IInstaller>().To(installer);
}
allInstallers.AddRange(container.InstallInstallers());
Assert.That(!container.HasBinding<IInstaller>());
}
foreach (var error in container.ValidateResolve<IDependencyRoot>())
{
yield return error;
}
// Also make sure we can fill in all the dependencies in the built-in scene
foreach (var monoBehaviour in compRoot.GetComponentsInChildren<MonoBehaviour>())
{
if (monoBehaviour == null)
{
// Be nice to give more information here
Log.Warn("Found null MonoBehaviour in scene");
continue;
}
foreach (var error in container.ValidateObjectGraph(monoBehaviour.GetType()))
{
yield return error;
}
}
// Validate dynamically created object graphs
foreach (var installer in allInstallers)
{
foreach (var error in installer.ValidateSubGraphs())
{
yield return error;
}
}
}
public void RegisterBindings(DiContainer container)
{
InstallerUtil.InstallUnityStandard(container);
container.Bind<IDependencyRoot>().AsSingle<GameRoot>();
container.Bind<Camera>().AsSingle(mainCamera);
container.Bind<LevelHelper>().AsSingle();
container.Bind<ITickable>().AsSingle<AsteroidSpawner>();
container.Bind<AsteroidSpawner>().AsSingle();
container.Bind<GuiHandler>().AsSingle(gui);
container.Bind<IFactory<Asteroid>>().AsSingle<GameObjectFactory<Asteroid>>();
container.Bind<GameObject>().AsSingle(asteroidTemplate).WhenInjectedInto<GameObjectFactory<Asteroid>>();
container.Bind<IEntryPoint>().AsSingle<GameController>();
container.Bind<ITickable>().AsSingle<GameController>();
container.Bind<GameController>().AsSingle();
container.Bind<Ship>().AsSingle(ship);
container.Bind<ShipStateFactory>().AsSingle();
}
