Example #1
0
 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>();
 }
Example #2
0
        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);
        }
Example #3
0
 static void InitDi()
 {
     DiContainer = new TinyIoCContainer();
     DiContainer.Register <IObservableClientAuthenticator, RestAuth>().AsMultiInstance();
     DiContainer.Register <IRestDatabase, RestDatabase>();
     DiContainer.Register <IValidator, Validator>();
 }
Example #4
0
        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.");
        }
Example #5
0
        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);
        }
Example #6
0
 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>();
 }
Example #7
0
        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);
        }
Example #8
0
 public UcWorldNodeVisualCache(IDiContainer di, ISceneNode node)
 {
     standardMaterialCache = di.Get <IStandardMaterialCache>();
     Node         = node;
     parentObj    = di.Get <IGlobalObjectService>().VisualObjects;
     unityObjects = new List <Pair <GameObject, MaterialPropertyBlock> >();
 }
Example #9
0
        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);
                }
            }
        }
Example #11
0
 protected virtual void StartupExtensions(IDiContainer di, IEnvironment environment)
 {
     foreach (var extension in environment.Extensions)
     {
         extension.OnStartup(di);
     }
 }
Example #12
0
 protected virtual void BindExtensions(IDiContainer di, IEnvironment environment)
 {
     foreach (var extension in environment.Extensions)
     {
         extension.Bind(di);
     }
 }
Example #13
0
 public void OnStartup(IDiContainer di)
 {
     di.Get <IGui>();
     di.Get <IMouseInputProvider>();
     di.Get <IKeyboardInputProvider>();
     di.Get <IWindowManager>();
 }
Example #14
0
 public void ValidateOnIoCContainerLoaded(IDiContainer diContainer, ICustomAutoGeneratedServiceInfo customAutoGeneratedServiceInfo)
 {
     if (_simulateValidateOnIoCContainerLoadedFails)
     {
         throw new Exception($"{nameof(ValidateOnIoCContainerLoaded)} failed.");
     }
 }
Example #15
0
        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);
        }
Example #16
0
        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();
        }
Example #18
0
        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));
        }
Example #19
0
        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);
        }
Example #20
0
        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>();
        }
Example #21
0
        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;
        }
Example #23
0
        public override void PrepareBasic()
        {
            this.container = new DiContainer(o => o.TryResolveUnregistered = false);

            RegisterDummies();
            RegisterStandard();
            RegisterComplexObject();
        }
Example #24
0
        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));
        }
Example #25
0
        public void Map(IDiContainer diContainer)
        {
            diContainer.Register <IPlugInLoader, PlugInLoader>();
            diContainer.Register <IMyMessageSubscriptionTester, MyMessageSubscriptionTester>();
            diContainer.Register <IMyPublicMessageCaller, MyPublicMessageCaller>();

            diContainer.Register <IEventBroker, EventBroker>(Scope.Singleton);
        }
Example #26
0
        public OalAudioSystem(IDiContainer di, IRenderLoopDispatcher renderLoopDispatcher)
        {
            di.Bind <IOalAudioRuntime>().AsLastChoice.To <OalAudioRuntime>();

            var runtime = di.Get <IOalAudioRuntime>();

            renderLoopDispatcher.Update += runtime.Update;
        }
Example #27
0
 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);
 }
Example #28
0
 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"));
        }
Example #30
0
        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; };
        }
Example #31
0
        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);
        }
Example #32
0
        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)
 {
 }
Example #36
0
 public PageResolutionTask(IDiContainer container, IViewModelManager viewModelManager)
 {
     mContainer = container;
       mViewModelmanager = viewModelManager;
 }
Example #37
0
 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)
 {
 }
Example #40
0
 public CommandParser(IDiContainer serviceLocator, IEnumerable<ICommandFactory> allCommands)
 {
     _serviceLocator = serviceLocator;
     _allCommands = allCommands;
 }
Example #41
0
 public ServiceResolutionTask(IDiContainer container)
 {
     mContainer = container;
 }
Example #42
0
 public StandardPackagesLoader(ILog log, IDiContainer container)
 {
     this.log = log;
     this.container = container;
 }
Example #43
0
 public void Initialize(IDiContainerFactory diContainerFactory)
 {
     _diContainer = diContainerFactory.Create();
 }
 public PresenterDelegationTask(IDiContainer container, IViewModelManager viewModelManager)
 {
     mContainer = container;
       mViewModelManager = viewModelManager;
 }