public InitializableHandler( [InjectOptional] List<IInitializable> initializables, [InjectOptional] List<Tuple<Type, int>> priorities, DiContainer container) { var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second); if (Assert.IsEnabled) { WarnForMissingBindings(initializables, container); } foreach (var initializable in initializables) { int priority; bool success = priorityMap.TryGetValue(initializable.GetType(), out priority); if (!success) { //Debug.LogWarning( //String.Format("IInitializable with type '{0}' does not have a priority assigned", //initializable.GetType())); } _initializables.Add( new InitializableInfo(initializable, success ? (int?)priority : null)); } }
public DisposablesHandler( [InjectOptional] List<IDisposable> disposables, [InjectOptional] List<Tuple<Type, int>> priorities, DiContainer container) { _container = container; var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second); foreach (var disposable in disposables) { int priority; bool success = priorityMap.TryGetValue(disposable.GetType(), out priority); if (!success) { //Log.Warn( //String.Format("IDisposable with type '{0}' does not have a priority assigned", //disposable.GetType())); } _disposables.Add( new DisposableInfo(disposable, success ? (int?)priority : null)); } Log.DebugFormat("Loaded {0} IDisposables to DisposablesHandler", _disposables.Count()); }
internal static void Inject(DiContainer container, object injectable, IEnumerable<object> additional, bool shouldUseAll, ZenjectTypeInfo typeInfo) { Assert.IsEqual(typeInfo.TypeAnalyzed, injectable.GetType()); Assert.That(injectable != null); var additionalCopy = additional.ToList(); foreach (var injectInfo in typeInfo.FieldInjectables.Concat(typeInfo.PropertyInjectables)) { bool didInject = InjectFromExtras(injectInfo, injectable, additionalCopy); if (!didInject) { InjectFromResolve(injectInfo, container, injectable); } } if (shouldUseAll && !additionalCopy.IsEmpty()) { throw new ZenjectResolveException( "Passed unnecessary parameters when injecting into type '{0}'. \nExtra Parameters: {1}\nObject graph:\n{2}" .With(injectable.GetType().Name(), String.Join(",", additionalCopy.Select(x => x.GetType().Name()).ToArray()), DiContainer.GetCurrentObjectGraph())); } foreach (var methodInfo in typeInfo.PostInjectMethods) { using (ProfileBlock.Start("{0}.{1}()".With(injectable.GetType(), methodInfo.Name))) { methodInfo.Invoke(injectable, new object[0]); } } }
public GenericBinder( DiContainer container, Type contractType, SingletonProviderMap singletonMap) : base(container, contractType) { Assert.That(contractType.IsOpenGenericType(), "Expected open generic type in GenericBinder"); _singletonMap = singletonMap; }
public Binder( DiContainer container, Type contractType) { _container = container; _contractType = contractType; }
public static void InjectGameObject(DiContainer container, GameObject gameObj) { foreach (var monoBehaviour in gameObj.GetComponents<MonoBehaviour>()) { InjectMonoBehaviour(container, monoBehaviour); } }
public StandardKernel( [InjectOptional] List<ITickable> tickables, [InjectOptional] List<Tuple<Type, int>> priorities, DiContainer container) { var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second); if (Assert.IsEnabled) { WarnForMissingBindings(tickables, container); } foreach (var tickable in tickables) { int priority; bool success = priorityMap.TryGetValue(tickable.GetType(), out priority); if (!success) { //Debug.LogWarning( //String.Format("Tickable with type '{0}' does not have a tick priority assigned", //tickable.GetType())); } var tickInfo = (success ? new TickableInfo(tickable, priority) : new TickableInfo(tickable)); _queuedTasks.Add(tickInfo); } }
public static void OutputObjectGraphToFile(DiContainer container, string outputPath) { #if !UNITY_WEBPLAYER // Output the entire object graph to file var graph = container.CalculateObjectGraph<IDependencyRoot>(); var resultStr = "digraph { \n"; foreach (var entry in graph) { // ignore these to clean up the graph if (entry.Key == typeof(EntryPointInitializer) || entry.Key == typeof(KernelInitializer)) { continue; } foreach (var dependencyType in entry.Value) { // ignore factory dependency to clean up graph if (dependencyType == typeof(DiContainer)) { continue; } resultStr += GetFormattedTypeName(entry.Key) + " -> " + GetFormattedTypeName(dependencyType) + "; \n"; } } resultStr += " }"; System.IO.File.WriteAllText(outputPath, resultStr); #endif }
public static void OutputObjectGraphForCurrentScene( DiContainer container, IEnumerable<Type> ignoreTypes, IEnumerable<Type> contractTypes) { string dotFilePath = EditorUtility.SaveFilePanel("Choose the path to export the object graph", "", "ObjectGraph", "dot"); if (!dotFilePath.IsEmpty()) { ObjectGraphVisualizer.OutputObjectGraphToFile( container, dotFilePath, ignoreTypes, contractTypes); var dotExecPath = EditorPrefs.GetString("Zenject.GraphVizDotExePath", ""); if (dotExecPath.IsEmpty() || !File.Exists(dotExecPath)) { EditorUtility.DisplayDialog( "GraphViz", "Unable to locate GraphViz. Please select the graphviz 'dot.exe' file which can be found at [GraphVizInstallDirectory]/bin/dot.exe. If you do not have GraphViz you can download it at http://www.graphviz.org", "Ok"); dotExecPath = EditorUtility.OpenFilePanel("Please select dot.exe from GraphViz bin directory", "", "exe"); EditorPrefs.SetString("Zenject.GraphVizDotExePath", dotExecPath); } if (!dotExecPath.IsEmpty()) { RunDotExe(dotExecPath, dotFilePath); } } }
public SingletonLazyCreator( DiContainer container, SingletonProviderMap owner, Type instanceType) { _container = container; _owner = owner; _instanceType = instanceType; }
// 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 static void InjectChildGameObjects( DiContainer container, GameObject gameObject, IEnumerable<object> extraArgs) { foreach (var monoBehaviour in gameObject.GetComponentsInChildren<MonoBehaviour>()) { InjectMonoBehaviour(container, monoBehaviour, extraArgs); } }
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 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 ShipStateFactory(DiContainer container) { _factories = new IFactory<ShipState>[(int) EShipState.Count] { new Factory<ShipState, ShipStateMoving>(container), new Factory<ShipState, ShipStateDead>(container), new Factory<ShipState, ShipStateWaitingToStart>(container), }; }
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 static void InjectMonoBehaviour( DiContainer container, MonoBehaviour monoBehaviour, IEnumerable<object> extraArgs) { // null if monobehaviour link is broken if (monoBehaviour != null && monoBehaviour.enabled) { using (container.PushLookup(monoBehaviour.GetType())) { FieldsInjecter.Inject(container, monoBehaviour, extraArgs); } } }
public LookupInProgressAdder(DiContainer container, Type concreteType) { if (DiContainer.LookupsInProgress.Contains(concreteType)) { Assert.That(false, () => "Circular dependency detected! \nObject graph:\n" + DiContainer.GetCurrentObjectGraph()); } DiContainer.LookupsInProgress.Push(concreteType); _container = container; _concreteType = concreteType; }
void InitContainer() { _container = new DiContainer(); // Note: This has to go first _container.Bind<CompositionRoot>().To(this); if (_extraBindingLookup != null) { _extraBindingLookup(_container); _extraBindingLookup = null; } }
static void InjectFromResolve( InjectableInfo injectInfo, DiContainer container, object targetInstance) { var valueObj = container.Resolve(injectInfo, targetInstance); if (valueObj == null && !container.AllowNullBindings) { // Do not change if optional // Since it may have some hard coded value Assert.That(injectInfo.Optional); // Should have thrown resolve exception otherwise } else { Assert.IsNotNull(injectInfo.Setter); injectInfo.Setter(targetInstance, valueObj); } }
static Dictionary<Type, List<Type>> CalculateObjectGraph( DiContainer container, IEnumerable<Type> contracts) { var map = new Dictionary<Type, List<Type>>(); foreach (var contractType in contracts) { var depends = GetDependencies(container, contractType); if (depends.Any()) { map.Add(contractType, depends); } } return map; }
public static void OutputObjectGraphToFile( DiContainer container, string outputPath, IEnumerable<Type> externalIgnoreTypes, IEnumerable<Type> contractTypes) { #if !UNITY_WEBPLAYER // Output the entire object graph to file var graph = CalculateObjectGraph(container, contractTypes); var ignoreTypes = new List<Type>() { typeof(DiContainer), typeof(InitializableHandler), typeof(StandardKernel), }; ignoreTypes.AddRange(externalIgnoreTypes); var resultStr = "digraph { \n"; resultStr += "rankdir=LR;\n"; foreach (var entry in graph) { if (ShouldIgnoreType(entry.Key, ignoreTypes)) { continue; } foreach (var dependencyType in entry.Value) { if (ShouldIgnoreType(dependencyType, ignoreTypes)) { continue; } resultStr += GetFormattedTypeName(entry.Key) + " -> " + GetFormattedTypeName(dependencyType) + "; \n"; } } resultStr += " }"; System.IO.File.WriteAllText(outputPath, resultStr); #endif }
// This method can be used to load the given scene and perform injection on its contents // Note that the scene we're loading can have [Inject] flags however it should not have // its own composition root public static IEnumerator LoadSceneAdditiveWithContainer( string levelName, DiContainer parentContainer) { var rootObjectsBeforeLoad = GameObject.FindObjectsOfType<Transform>().Where(x => x.parent == null).ToList(); Application.LoadLevelAdditive(levelName); // Wait one frame for objects to be added to the scene heirarchy yield return null; var rootObjectsAfterLoad = GameObject.FindObjectsOfType<Transform>().Where(x => x.parent == null).ToList(); foreach (var newObject in rootObjectsAfterLoad.Except(rootObjectsBeforeLoad).Select(x => x.gameObject)) { Assert.That(newObject.GetComponent<CompositionRoot>() == null, "LoadSceneAdditiveWithContainer does not expect a container to exist in the loaded scene"); InjectionHelper.InjectChildGameObjects(parentContainer, newObject); } }
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(); }
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; } } }
internal SaberFactory(DiContainer container) { _container = container; }
public static void Inject(DiContainer container, object injectable, IEnumerable<object> additional, bool shouldUseAll) { Inject(container, injectable, additional, shouldUseAll, TypeAnalyzer.GetInfo(injectable.GetType())); }
public static void Inject(DiContainer container, object injectable) { Inject(container, injectable, Enumerable.Empty<object>()); }
public static void Bind(DiContainer container, IEnumerable <string> systemNamespaces) { new BindSystemsInNamespace(container, systemNamespaces).Bind(); }
static void InstallFoo2(DiContainer container) { container.Bind <Foo>().AsSingle(); container.BindSignal <DoSomethingSignal>().To <Bar>(x => x.Execute).AsSingle(); }
public ArenasFactory(PrefabArenaData prefabArenaData, DiContainer diContainer) { _prefabArenasData = prefabArenaData; _diContainer = diContainer; }
public override void PostBindings(DiContainer container) { var eventBus = container.Resolve <EventBus>(); var poolStorageController = container.Resolve <PoolStorageController>(); eventBus.On((int) Events.GameLevelLoad, poolStorageController.OnLevelLoad); var btnController = container.Resolve <BtnController>(); eventBus.On((int) Events.BtnClick, btnController.OnClick); var showableController = container.Resolve <ShowableController>(); eventBus.On((int) Events.ShowableShow, showableController.OnShow); eventBus.On((int) Events.ShowablePreShow, showableController.OnPreShow); var activityIndicatorController = container.Resolve <ActivityIndicatorController>(); eventBus.On((int)Events.ServerRequest, activityIndicatorController.OnServerRequest); eventBus.On((int)Events.ServerResponse, activityIndicatorController.OnServerResponse); var errorController = container.Resolve <ErrorController>(); eventBus.On((int) Events.ServerResponse, errorController.OnServerResponse); var gameController = container.Resolve <GameController>(); eventBus.On((int)Events.LevelGeneratorLevelGenerate, gameController.OnLevelGenerate); var levelStartScreen = container.Resolve <LevelStartScreenView>() .GetComponent <ShowableView>(); levelStartScreen.OnHide += gameController.OnLevelStartScreenHide; var gameOverScreen = container.Resolve <GameOverScreenView>(); var gameOverScreenShowable = gameOverScreen.GetComponent <ShowableView>(); gameOverScreenShowable.OnShow += gameController.OnGameOverScreenShow; gameOverScreenShowable.OnHide += gameController.OnGameOverScreenHide; var tutorialScreen = container.Resolve <TutorialScreenView>() .GetComponent <ShowableView>(); tutorialScreen.OnPreShow += gameController.OnTutorialPreShow; tutorialScreen.OnHide += gameController.OnTutorialHide; var everyplayController = container.Resolve <EveryplayController>(); eventBus.On((int) Events.GameLevelUnload, everyplayController.OnLevelUnload); eventBus.On((int) Events.GamePreLevelLoad, everyplayController.OnPreLevelLoad); eventBus.On((int)Events.PlayerResurrect, everyplayController.OnPlayerResurrect); eventBus.On((int)Events.PlayerManagerPreLevelComplete, everyplayController.OnPreLevelComplete); gameOverScreenShowable.OnShow += everyplayController.OnGameOverScreenShow; levelStartScreen.OnShow += everyplayController.OnLevelStartScreenShow; var levelCompleteScreen = container.Resolve <LevelCompleteScreenView>(); levelCompleteScreen.GetComponent <ShowableView>().OnShow += everyplayController.OnLevelCompleteScreenShow; var analyticsController = container.Resolve <AnalyticsController>(); eventBus.On((int)Events.PlayerManagerPreLevelComplete, analyticsController.OnPreLevelComplete); eventBus.On((int)Events.PlayerDeath, analyticsController.OnPlayerDeath); eventBus.On((int)Events.PlayerResurrect, analyticsController.OnPlayerResurrect); eventBus.On((int)Events.PlayerConstruct, analyticsController.OnPlayerConstruct); eventBus.On((int)Events.AppStart, analyticsController.OnAppStart); eventBus.On((int)Events.SkillListItemLearnBtnClick, analyticsController.OnSkillListItemLearnBtnClick); var mainScreen = container.Resolve <MainScreenView>(); mainScreen.FeedbackBtn.onClick.AddListener( analyticsController.OnMainScreenFeedbackBtnClick); mainScreen.StartBtn.onClick.AddListener( analyticsController.OnMainScreenStartBtnClick); mainScreen.LeaderboardBtn.onClick.AddListener( analyticsController.OnMainScreenLeaderboardBtnClick); mainScreen.AchievementsBtn.onClick.AddListener( analyticsController.OnMainScreenAchievementsBtnClick); mainScreen.ReplaysBtn.onClick.AddListener( analyticsController.OnMainScreenReplaysBtnClick); mainScreen.ExitBtn.onClick.AddListener( analyticsController.OnMainScreenExitBtnClick); mainScreen.SkillsBtn.onClick.AddListener( analyticsController.OnMainScreenSkillsBtnClick); gameOverScreen.ExitBtn.onClick.AddListener( analyticsController.OnGameOverScreenExitBtnClick); gameOverScreen.RestartBtn.onClick.AddListener( analyticsController.OnGameOverScreenRestartBtnClick); levelCompleteScreen.ShareBtn.onClick.AddListener( analyticsController.OnLevelCompleteScreenShareBtnClick); var ad = container.Resolve <Ad>(); ad.OnView += analyticsController.OnAdView; var authManager = container.Resolve <AuthManager>(); authManager.OnLoginSuccess += analyticsController.OnLogin; var uiBlockerController = container.Resolve <UIBlockerController>(); eventBus.On((int)Events.ServerRequest, uiBlockerController.OnServerRequest); eventBus.On((int)Events.ServerResponse, uiBlockerController.OnServerResponse); }
public SimpleBulletFactory(DiContainer container, [Inject(Id = WeaponInstaller.ID_BulletsContainer)] Transform parent) { _parent = parent; _container = container; }
public override void InitBindings(DiContainer container) { Server finalServer = server; if (UnityEngine.Debug.isDebugBuild && isServerStubbed) { finalServer = serverStub; } container.Bind <Server>().ToSingleMethod((InjectContext context) => { context.Container.Inject(finalServer); return(finalServer); }); container.Bind <AuthManager>().ToSingle(); container.Bind <EventBus>().ToSingle(); container.Bind <Translator>().ToSingle(); container.Bind <Game>().ToSingle(); container.Bind <PoolStorageController>().ToSingle(); container.Bind <ActivityIndicatorController>().ToSingle(); container.Bind <Ad>().ToSingle(); container.Bind <BtnController>().ToSingle(); container.Bind <ShowableController>().ToSingle(); container.Bind <ErrorController>().ToSingle(); container.Bind <GameController>().ToSingle(); container.Bind <EveryplayController>().ToSingle(); container.Bind <AnalyticsController>().ToSingle(); container.Bind <UIBlockerController>().ToSingle(); container.Bind <PoolStorageView>().ToInstance(poolStorage); container.Bind <UIView>().ToInstance(ui); container.Bind <CoroutineManagerView>().ToInstance(coroutineManager); container.Bind <ScreenSpacePopupManagerView>() .ToInstance(screenSpacePopupManager); container.Bind <ActivityIndicatorView>() .ToInstance(activityIndicator); container.Bind <Camera>("MainCamera").ToInstance(mainCamera); container.Bind <AudioManager>() .ToSingleMethod((InjectContext context) => { context.Container.Inject(audioManager); return(audioManager); }); container.Bind <UIBlockerView>().ToInstance(uiBlocker); container.Bind <WorldSpacePopupManagerView>() .ToInstance(worldSpacePopupManager); container.Bind <Stopwatch>("PlayStopwatch") .ToInstance(new Stopwatch()); container.Bind <TutorialScreenView>().ToInstance(tutorialScreen); container.Bind <string>("EmptyScene").ToInstance(emptyScene); container.Bind <string>("FeedbackEmail").ToInstance(feedbackEmail); container.Bind <string>("ErrorMsg").ToInstance(errorMsg); container.Bind <int>("ErrorPopupType").ToInstance(errorPopupType); container.Bind <int>("CommonPopupType").ToInstance(commonPopupType); container.Bind <byte[]>("SecretKey") .ToInstance(Encoding.UTF8.GetBytes(secretKey)); container.Bind <int>("EffectsHighPrioAudioChannel") .ToInstance(effectsHighPrioAudioChannel); container.Bind <int>("EffectsLowPrioAudioChannel") .ToInstance(effectsLowPrioAudioChannel); container.Bind <int>("UIHighPrioAudioChannel") .ToInstance(uiHighPrioAudioChannel); container.Bind <int>("UILowPrioAudioChannel") .ToInstance(uiLowPrioAudioChannel); container.Bind <int>("PlayerHighPrioAudioChannel") .ToInstance(playerHighPrioAudioChannel); container.Bind <int>("PlayerMidPrioAudioChannel") .ToInstance(playerMidPrioAudioChannel); container.Bind <int>("PlayerLowPrioAudioChannel") .ToInstance(playerLowPrioAudioChannel); }
public void Install() { Assert.That(!_hasInstalled); _hasInstalled = true; Assert.IsNull(_container); var parents = GetParentContainers(); Assert.That(!parents.IsEmpty()); Assert.That(parents.All(x => x.IsValidating == parents.First().IsValidating)); _container = new DiContainer(parents, parents.First().IsValidating); // Do this after creating DiContainer in case it's needed by the pre install logic if (PreInstall != null) { PreInstall(); } if (OnPreInstall != null) { OnPreInstall.Invoke(); } Assert.That(_decoratorContexts.IsEmpty()); _decoratorContexts.AddRange(LookupDecoratorContexts()); if (_parentNewObjectsUnderSceneContext) { _container.DefaultParent = transform; } else { _container.DefaultParent = null; } // Record all the injectable components in the scene BEFORE installing the installers // This is nice for cases where the user calls InstantiatePrefab<>, etc. in their installer // so that it doesn't inject on the game object twice // InitialComponentsInjecter will also guarantee that any component that is injected into // another component has itself been injected var injectableMonoBehaviours = new List <MonoBehaviour>(); GetInjectableMonoBehaviours(injectableMonoBehaviours); foreach (var instance in injectableMonoBehaviours) { _container.QueueForInject(instance); } foreach (var decoratorContext in _decoratorContexts) { decoratorContext.Initialize(_container); } _container.IsInstalling = true; try { InstallBindings(injectableMonoBehaviours); } finally { _container.IsInstalling = false; } if (PostInstall != null) { PostInstall(); } if (OnPostInstall != null) { OnPostInstall.Invoke(); } }
public void Setup() { _container = new DiContainer(); }
public GameLoader(ZenjectSceneLoader sceneLoader, DiContainer container) { this.sceneLoader = sceneLoader; this.container = container; }
public WeaponFactory(DiContainer diContainer) { this.diContainer = diContainer; }
static void InstallFoo(DiContainer container) { container.Bind <Foo>().AsSingle(); container.DeclareSignal <DoSomethingSignal>(); }
private static FactoryToChoiceIdBinder <GameObject, Type, T> BindUiFactory <T, TFactory>(DiContainer container) { var bindStatement = container.StartBinding(); var bindInfo = bindStatement.SpawnBindInfo(); bindInfo.ContractTypes.Add(typeof(TFactory)); var factoryBindInfo = new FactoryBindInfo(typeof(TFactory)); bindStatement.SetFinalizer(new PlaceholderFactoryBindingFinalizer <T>(bindInfo, factoryBindInfo)); return(new FactoryToChoiceIdBinder <GameObject, Type, T>(container, bindInfo, factoryBindInfo)); }
/// <summary> /// Get the adapter for the specified <see cref="DiContainer"/>. /// </summary> public static IContainer GetAdapter(DiContainer container) => container switch {
public AlertFactory(DiContainer diContainer) { _diContainer = diContainer; }
public CustomFooFactory(DiContainer container) { _container = container; }
public FactoryToChoiceBinder( DiContainer bindContainer, BindInfo bindInfo, FactoryBindInfo factoryBindInfo) : base(bindContainer, bindInfo, factoryBindInfo) { }
public BindSystemsInNamespace(DiContainer container, IEnumerable <string> systemNamespaces) { Container = container; SystemNamespaces = systemNamespaces; }
public virtual void Destroy() { _container = null; }
void InstallQux(DiContainer subContainer) { subContainer.Bind <Qux>().AsSingle(); }
private static SaberProvider GetProvider(DiContainer container) { var provider = container.TryResolve <SaberProvider>(); return(provider); }
public CommandBinder( DiContainer container, string identifier, SingletonProviderCreator singletonProviderFactory) : base(container, identifier, singletonProviderFactory) { }
public void TestInitialize() { container = new DiContainer(); }
public CommandBinderBase( DiContainer container, string identifier, SingletonProviderCreator singletonProviderFactory) : base(container, typeof(TCommand), identifier) { _singletonProviderFactory = singletonProviderFactory; }
public static void Inject(DiContainer container, object injectable, IEnumerable<object> additional) { Inject(container, injectable, additional, false); }
public VisualFactoryRef(DiContainer container) : base(container) { }
public void Setup() { _container = new DiContainer(); _container.Bind <TaskUpdater <ITickable> >().FromInstance(new TickablesTaskUpdater()); }
public GameObjectFactory(DiContainer container, ISceneHelper sceneHelper) { this.container = container; this.sceneHelper = sceneHelper; }
public override void Install(DiContainer container) { container .BindInterfacesTo <MmfBasedMessageIo>() .AsCached(); }
public TowerFactory(DiContainer container, TowerTypeMap typeMap) { _container = container; _typeMap = typeMap; }
public ConcreteIdBinderNonGeneric( DiContainer bindContainer, BindInfo bindInfo, BindStatement bindStatement) : base(bindContainer, bindInfo, bindStatement) { }
public ContainerBindingTests() { _container = new DiContainer(); }