public void Bind(IDiContainer di) { di.BindMulti <IAssetLoader>().To <FFmpegMovieLoader>(); di.Bind <IMoviePlayer>().To <FFmpegMoviePlayer>(); di.Bind <IMovieUrlLoader>().To <FFmpegMovieUrlLoader>(); di.Bind <FFmpegInitializer>().AsLastChoice.To <FFmpegInitializer>(); }
private static async Task <bool> Test(IDiContainer container, TestInfo info) { Console.WriteLine($"-------------------------- {info.Title} BEGIN ------------------------------"); Console.WriteLine(); Console.WriteLine(info.Description); var posTerminal = container.Resolve <IPosTerminal>(); foreach (var itemCode in info.ItemCodes) { posTerminal.ScanItemCode(itemCode); } foreach (var revokedCode in info.RevokedItemCodes) { posTerminal.RemoveItemCode(revokedCode); } var actualTotal = await posTerminal.CalculateTotalAsync().ConfigureAwait(false); var passes = info.ExpectedTotal == actualTotal; Console.WriteLine(); Console.WriteLine(posTerminal); Console.WriteLine($"\nExpected: {info.ExpectedTotal}\nActual: {actualTotal}\nPasses: {passes}"); Console.WriteLine(); Console.WriteLine($"-------------------------- {info.Title} END ------------------------------"); return(passes); }
static void InitDi() { DiContainer = new TinyIoCContainer(); DiContainer.Register <IObservableClientAuthenticator, RestAuth>().AsMultiInstance(); DiContainer.Register <IRestDatabase, RestDatabase>(); DiContainer.Register <IValidator, Validator>(); }
public object BuildSingle(IDiContainer di, DiBuildInstanceType buildInstanceType) { if (abstractType.ContainsGenericParameters) { throw new InvalidOperationException($"Trying to obtain an instance of a non-complete generic type '{abstractType}'."); } foreach (var item in items) { if (item.Condition(di)) { return(item.Binding.BuildInstance(di, Type.EmptyTypes, buildInstanceType)); } } if (abstractType.IsGenericType) { var genericItems = GetGenericItems(di, DiRootBindingType.Single); foreach (var item in genericItems) { if (item.Condition(di)) { return(item.Binding.BuildInstance(di, abstractType.GetGenericArguments(), buildInstanceType)); } } } if (concreteTypeBinding != null) { return(concreteTypeBinding.BuildInstance(di, abstractType.GetGenericArguments(), buildInstanceType)); } throw new KeyNotFoundException($"No valid bindings found for '{abstractType.FullName}' implementations."); }
public void RegisterNamedSpecificInstanceAsSingleton() { const string info = @"container .RegisterInstance<IFoo>(specificInstance1) .RegisterInstance<IFoo>(""foo2"", specificInstance2); "; Foo specificInstance1 = new Foo(); Foo specificInstance2 = new Foo(); IDiContainer container = CreateConntainer(); container .RegisterInstance <IFoo>(specificInstance1) .RegisterInstance <IFoo>("foo2", specificInstance2); const string additionalInfo1 = "container.GetInstance<IFoo>();"; IFoo instance1 = container.GetInstance <IFoo>(); instance1.Should().BeSameAs(specificInstance1, info + additionalInfo1); IFoo instance2 = container.GetInstance <IFoo>(); instance2.Should().BeSameAs(specificInstance1, info + additionalInfo1); const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\");"; IFoo instance3 = container.GetInstance <IFoo>("foo2"); instance3.Should().BeSameAs(specificInstance2, info + additionalInfo2); IFoo instance4 = container.GetInstance <IFoo>("foo2"); instance4.Should().BeSameAs(specificInstance2, info + additionalInfo2); }
public void Bind(IDiContainer di) { GenOutput.FillDomain(GenDomain.Static); di.Bind <ProgramObject>().To(programObjComponent); di.Bind <IAmDiBasedObjectFactory>().To(d => new AmJitsuGenDiBasedObjectFactory(d.Get)); di.Bind <IWindowingSystem>().To <UcGui>(); di.Bind <IGui>().To <UcGui>(); di.Bind <IRenderService>().To <UcRenderService>(); di.Bind <IDefaultStateInitializer>().To <UcDefaultStateInitializer>(); di.Bind <IMoviePlayer>().To <UcCgMoviePlayer>(); di.Bind <IUcRenderingInfra>().To <UcRenderingInfra>(); di.Bind <IImageLoader>().To <UcImageLoader>(); di.BindMulti <IUcInputProvider>().To <UcMouseInputProvider>(); di.BindMulti <IUcInputProvider>().To <UcKeyboardInputProvider>(); di.Bind <IVrHeadPositionService>().To <VrHeadPositionService>(); di.Bind <IStandardMaterialCache>().To <StandardMaterialCache>(); di.Bind <IRtImageBuilder>().To <UcRtImageBuilder>(); di.Bind <IRichTextMeasurer>().To <UcRichTextMeasurer>(); di.Bind <IMessageBoxService>().To <MessageBoxService>(); di.Bind <IVrInitializerService>().To <VrInitializerService>(); di.Bind <IGlobalObjectService>().To <GlobalObjectService>(); di.Bind <IVrManipulationService>().To <VrManipulationService>(); di.Bind <ILogService>().To <UcLogService>(); di.Bind <IMessagePopupService>().To <UcMessagePopupService>(); di.Bind <IVrInputDispatcher>().To <NoviceVrInputDispatcher>(); di.BindMulti <IVrNavigationMode>().To <MinimapVrNavigationMode>(); //di.BindMulti<IVrNavigationMode>().To<FixedTeleportVrNavigationMode>(); //di.BindMulti<IVrNavigationMode>().To<FixedSmoothVrNavigationMode>(); di.BindMulti <IVrNavigationMode>().To <FreeSmoothVrNavigationMode>(); di.BindMulti <IVrNavigationMode>().To <MoveInPlaceVrNavigationMode>(); di.BindMulti <IVrNavigationMode>().To <FreeTeleportVrNavigationMode>(); }
public async Task Run() { _container = CreateDiContainer(); var apiBuilder = _container.GetInstance <IXmlRpcProxyBuilder <IHomeMaticXmlRpcApi> >(); var xmlRpcApiHmIp = apiBuilder .ForUrl("http://homematic-ccu2:" + CcuRpcPorts.HomeMaticIp) .Build(); var xmlRpcApi = apiBuilder .ForUrl("http://homematic-ccu2:" + CcuRpcPorts.HomeMatic) .Build(); var connection = new CcuConnection(xmlRpcApiHmIp); var deviceInfos = await connection.GetDeviceInfosAsync(); var devices = await connection.GetDevicesAsync(); var temperature = await xmlRpcApi.GetValueAsync <double>("NEQ1142873:1", "TEMPERATURE"); Console.WriteLine($"Temperature: {temperature}"); var deviceDescriptions = await xmlRpcApiHmIp.ListDevicesAsync(); deviceDescriptions.ForEach(x => Console.WriteLine($"{x.Address}")); Console.WriteLine(); await LoadParameterDescriptions(xmlRpcApiHmIp); }
public UcWorldNodeVisualCache(IDiContainer di, ISceneNode node) { standardMaterialCache = di.Get <IStandardMaterialCache>(); Node = node; parentObj = di.Get <IGlobalObjectService>().VisualObjects; unityObjects = new List <Pair <GameObject, MaterialPropertyBlock> >(); }
public object BuildInstance(IDiContainer di, Type[] genericArguments, DiBuildInstanceType buildInstanceType) { var resolvedCtor = ResolveGenerics(constructor, genericArguments); var parameters = resolvedCtor.GetParameters().Select(x => di.Get(x.ParameterType)).ToArray(); return(resolvedCtor.Invoke(parameters)); }
public void TestCreateScope <TService, TImplementation>(IDiContainer container) where TService : class { using (var scope = container.CreateScope()) { container = scope.Container; var service = container.GetInstance <TService>(); Xunit.Assert.IsType <TImplementation>(service); var service2 = container.GetInstance <TService>(); Xunit.Assert.IsType <TImplementation>(service2); Xunit.Assert.Equal(service, service2); using (var innerScope = container.CreateScope()) { var scopedService = innerScope.Container.GetInstance <TService>(); Xunit.Assert.IsType <TImplementation>(scopedService); var scopedService2 = innerScope.Container.GetInstance <TService>(); Xunit.Assert.IsType <TImplementation>(scopedService2); Xunit.Assert.Equal(scopedService, scopedService2); Xunit.Assert.NotEqual(service, scopedService); } } }
protected virtual void StartupExtensions(IDiContainer di, IEnvironment environment) { foreach (var extension in environment.Extensions) { extension.OnStartup(di); } }
protected virtual void BindExtensions(IDiContainer di, IEnvironment environment) { foreach (var extension in environment.Extensions) { extension.Bind(di); } }
public void OnStartup(IDiContainer di) { di.Get <IGui>(); di.Get <IMouseInputProvider>(); di.Get <IKeyboardInputProvider>(); di.Get <IWindowManager>(); }
public void ValidateOnIoCContainerLoaded(IDiContainer diContainer, ICustomAutoGeneratedServiceInfo customAutoGeneratedServiceInfo) { if (_simulateValidateOnIoCContainerLoadedFails) { throw new Exception($"{nameof(ValidateOnIoCContainerLoaded)} failed."); } }
public void RegisterNamedInterfaceWithClassAndReturnNewInstanceOnEachResolve() { const string info = @"container .Register<IFoo, Foo>() .Register<IFoo, Foo>(""foo2""); "; IDiContainer container = CreateConntainer(); container .Register <IFoo, Foo>() .Register <IFoo, Foo>("foo2"); const string additionalInfo1 = "container.GetInstance<IFoo>();"; IFoo instance1 = container.GetInstance <IFoo>(); instance1.Should() .NotBeNull(info + additionalInfo1) .And.BeOfType <Foo>(info + additionalInfo1); const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\");"; IFoo instance2 = container.GetInstance <IFoo>("foo2"); instance2.Should() .BeOfType <Foo>(info + additionalInfo2) .And.NotBeSameAs(instance1, info + additionalInfo2); }
public void AddMessageSubscription(IDiContainer diContainer, IEventBroker eventBroker) { Console.WriteLine(nameof(PlugIn.AddMessageSubscription)); var logicClass = diContainer.Get <ISecondLogicClass>(); logicClass.Subscribe(); }
public void TestScopeDisposeDouble(IDiContainer container) { var scope = container.CreateScope(); scope.Dispose(); scope.Dispose(); }
public object BuildInstance(IDiContainer di, Type[] genericArguments, DiBuildInstanceType buildInstanceType) { var resolvedMethod = method.IsGenericMethod ? method.MakeGenericMethod(genericArguments) : method; var parameters = resolvedMethod.GetParameters().Select(x => di.Get(x.ParameterType)).ToArray(); return(resolvedMethod.Invoke(obj, parameters)); }
public void RegisterNamedInterfaceWithClassAsSingleton() { const string info = @"container .RegisterInstance<IFoo, Foo>() .RegisterInstance<IFoo, Foo>(""foo2""); "; IDiContainer container = CreateConntainer(); container .RegisterInstance <IFoo, Foo>() .RegisterInstance <IFoo, Foo>("foo2"); const string additionalInfo1 = "container.GetInstance<IFoo>();"; IFoo instance1 = container.GetInstance <IFoo>(); instance1.Should().NotBeNull(info + additionalInfo1); IFoo instance2 = container.GetInstance <IFoo>(); instance2.Should().BeSameAs(instance1, info + additionalInfo1); const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\")"; IFoo instance3 = container.GetInstance <IFoo>("foo2"); instance3.Should() .NotBeNull(info + container.GetInstance <IFoo>("foo2")) .And.NotBeSameAs(instance1, info + additionalInfo2); IFoo instance4 = container.GetInstance <IFoo>("foo2"); instance4.Should().BeSameAs(instance3, info + additionalInfo2); }
public void ResolveItemsFormChildContainer() { IDiContainer container = CreateConntainer(); container .Register <IFoo, Foo>() .Register <IBar, Bar>(); IDiContainer childContainer = container.CreateChildContainer(); childContainer.Register <IFoo, FooChild>(); IFoo instance = container.GetInstance <IFoo>(); instance.Should() .NotBeNull() .And.BeOfType <Foo>(); IFoo childInstance = childContainer.GetInstance <IFoo>(); childInstance.Should() .NotBeNull() .And.BeOfType <FooChild>(); IBar parentInstance = childContainer.GetInstance <IBar>(); parentInstance.Should() .NotBeNull() .And.BeOfType <Bar>(); (parentInstance as Bar).Foo.Should() .NotBeNull() .And.BeOfType <FooChild>(); }
private IEnumerable<ICommandFactory> RegisteCommands(IDiContainer serviceLocator) { var commands = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetTypes()) .Where(t => typeof(ICommandFactory).IsAssignableFrom(t) && t.IsClass); return commands.Select(item => Activator.CreateInstance(item, serviceLocator) as ICommandFactory); }
public DiContainerScope(IDiContainer container, Action disposeCallback) { Ensure.IsNotNull(container, nameof(container)); Ensure.IsNotNull(disposeCallback, nameof(disposeCallback)); Container = container; _disposeCallback = disposeCallback; }
public override void PrepareBasic() { this.container = new DiContainer(o => o.TryResolveUnregistered = false); RegisterDummies(); RegisterStandard(); RegisterComplexObject(); }
private IEnumerable <ICommandFactory> RegisteCommands(IDiContainer serviceLocator) { var commands = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetTypes()) .Where(t => typeof(ICommandFactory).IsAssignableFrom(t) && t.IsClass); return(commands.Select(item => Activator.CreateInstance(item, serviceLocator) as ICommandFactory)); }
public void Map(IDiContainer diContainer) { diContainer.Register <IPlugInLoader, PlugInLoader>(); diContainer.Register <IMyMessageSubscriptionTester, MyMessageSubscriptionTester>(); diContainer.Register <IMyPublicMessageCaller, MyPublicMessageCaller>(); diContainer.Register <IEventBroker, EventBroker>(Scope.Singleton); }
public OalAudioSystem(IDiContainer di, IRenderLoopDispatcher renderLoopDispatcher) { di.Bind <IOalAudioRuntime>().AsLastChoice.To <OalAudioRuntime>(); var runtime = di.Get <IOalAudioRuntime>(); renderLoopDispatcher.Update += runtime.Update; }
public UcGui(IDiContainer di, IEventRoutingService eventRoutingService) { this.di = di; renderControl = new UcRenderGuiControl(); this.eventRoutingService = eventRoutingService; eventRoutingService.RegisterServiceDependency(typeof(UcGui), typeof(IWorldTreeService)); eventRoutingService.SubscribeToAllAfter(typeof(UcGui).FullName, OnEveryEvent, true); }
public ServiceLocator(IDiContainer container) { if (Current != null) { return; } Current = container; }
public void TestGetInstanceThrowsException <TService>(IDiContainer container) where TService : class { Xunit.Assert.Throws <ResolveFailedException>(container.GetInstance <TService>); Xunit.Assert.Throws <ResolveFailedException>(() => container.GetInstance(typeof(TService))); Xunit.Assert.Throws <ResolveFailedException>(() => container.GetInstance <TService>("1")); }
protected static void ClassInitializeCommon(DiImplementationType diImplementationType, Action <ConfigurationFileXmlDocumentLoadedEventArgs> configurationFileXmlDocumentLoadedEventHandler) { // JetBrains.ReSharper.TestRunner.Merged TestsHelper.SetupLogger(); Log4Tests.LogLevel = LogLevel.Debug; _diImplementationType = diImplementationType; _mainLifeTimeScopeTerminatedExecuted = false; var diContainerBuilder = new DiContainerBuilder.DiContainerBuilder(); var fileBasedConfigurationParameters = new FileBasedConfigurationParameters(new FileBasedConfigurationFileContentsProvider( Path.Combine(Helpers.TestsEntryAssemblyFolder, "IoCConfiguration_Overview.xml")), Helpers.TestsEntryAssemblyFolder, new LoadedAssembliesForTests()) { AttributeValueTransformers = new[] { new FileFolderPathAttributeValueTransformer() }, ConfigurationFileXmlDocumentLoaded = (sender, e) => { Helpers.EnsureConfigurationDirectoryExistsOrThrow(e.XmlDocument.SelectElement("/iocConfiguration/appDataDir").GetAttribute("path")); Helpers.ReplaceActiveDiManagerInConfigurationFile(e.XmlDocument, _diImplementationType); configurationFileXmlDocumentLoadedEventHandler?.Invoke(e); } }; _containerInfo = diContainerBuilder.StartFileBasedDi( fileBasedConfigurationParameters, out _) .WithoutPresetDiContainer() .AddAdditionalDiModules(new TestModule2()) .RegisterModules() .Start(); _diContainer = _containerInfo.DiContainer; var injectedStartupActionsHelper = _diContainer.Resolve <ClassToTestServicesInjection <IStartupAction> >(); _startupActionsToTest = injectedStartupActionsHelper.Implementations.Where(x => x is IStartupActionState && new[] { "DynamicallyLoadedAssembly1.Implementations.StartupAction1", "DynamicallyLoadedAssembly1.Implementations.StartupAction2" } .Contains(x.GetType().FullName)).ToList(); var injectedPluginsHelper = _diContainer.Resolve <ClassToTestServicesInjection <IPlugin> >(); _pluginsToTest = injectedPluginsHelper.Implementations.Where(x => x is IPluginState && new[] { "TestPluginAssembly1.Implementations.Plugin1", "TestPluginAssembly2.Implementations.Plugin2" } .Contains(x.GetType().FullName)).ToList(); _diContainer.MainLifeTimeScope.LifeTimeScopeTerminated += (sender, e) => { _mainLifeTimeScopeTerminatedExecuted = true; }; }
public static IDiContainer Configure(IDiContainer container) { container.Register <IPosTerminal, SimplePosTerminal>().LifeTimeMode = InstanceLifeTimeMode.NewInstance; container.Register <IPriceCalculator, SimplePriceCalculator>().LifeTimeMode = InstanceLifeTimeMode.NewInstance; container.Register <IShoppingCart, ShoppingCart>().LifeTimeMode = InstanceLifeTimeMode.NewInstance; container.Register <IProductRepository, FakeProductRepository>().LifeTimeMode = InstanceLifeTimeMode.NewInstance; container.Register <IProductOfferRepository, FakeProductOfferRepository>().LifeTimeMode = InstanceLifeTimeMode.NewInstance; return(container); }
public override void Init(IDiContainer container, IViewModelManager vmManager, IMessagingManager messagingManager, IPresenter presenter, ILogger logger) { mContainer = container; mLogger = logger; MainPage = new ContentPage(); }
public BaseUtilsPresenterDelegationTask(IDiContainer container, IViewModelManager viewModelManager) : base(container, viewModelManager) { Container = container; }
public NavigationPagePresenterDelegationTask(IDiContainer container, IViewModelManager viewModelManager) : base(container, viewModelManager) { }
public ReadCommandFactory(IDiContainer serviceLocator) : base(serviceLocator) { }
public PageResolutionTask(IDiContainer container, IViewModelManager viewModelManager) { mContainer = container; mViewModelmanager = viewModelManager; }
public abstract void Init(IDiContainer container, IViewModelManager vmManager, IMessagingManager messagingManager, IPresenter presenter, ILogger logger);
protected BaseCommandFactory(IDiContainer serviceLocator) { ServiceLocator = serviceLocator; }
public WallCommandFacotry(IDiContainer serviceLocator) : base(serviceLocator) { }
public CommandParser(IDiContainer serviceLocator, IEnumerable<ICommandFactory> allCommands) { _serviceLocator = serviceLocator; _allCommands = allCommands; }
public ServiceResolutionTask(IDiContainer container) { mContainer = container; }
public StandardPackagesLoader(ILog log, IDiContainer container) { this.log = log; this.container = container; }
public void Initialize(IDiContainerFactory diContainerFactory) { _diContainer = diContainerFactory.Create(); }
public PresenterDelegationTask(IDiContainer container, IViewModelManager viewModelManager) { mContainer = container; mViewModelManager = viewModelManager; }