private void ValidateFileBasedDiContainer(DiImplementationType diImplementationType, IDiContainer diContainer) { Assert.IsNotNull(diContainer.Resolve <ISettings>()); Assert.IsNotNull(diContainer.Resolve <IPluginsSetup>()); Assert.IsNotNull(diContainer.Resolve <IPluginDataRepository>()); Assert.IsNotNull(diContainer.Resolve <IOnApplicationsStarted>()); ValidateDiContainer(diImplementationType, diContainer); }
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 void Initialize() { _container.Register <Note>(); _container.Register <DataManager>(); _container.Register <List <Note> >(); _firstNote = _container.Resolve <Note>(parameters: new object[] { (sbyte)1, "Watch movie", "Watch Thor 3", DateTime.Now }); _secondNote = _container.Resolve <Note>(parameters: new object[] { (sbyte)2, "Street", "Go for a walk", DateTime.Now }); _dataManager = _container.Resolve <DataManager>(parameters: new object[] { _container }); }
public void Dispatch <TCommand>(TCommand command) where TCommand : Command { var commandHandler = diContainer.Resolve <ICommandHandler <TCommand> >(); var transactionalCommandHandler = new TransactionalCommandHandler <TCommand>(commandHandler, diContainer); transactionalCommandHandler.Execute(command); }
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); }
public void Dispatch <TCommand>(TCommand command) where TCommand : Command { var commandHandler = diContainer.Resolve <ICommandHandler <TCommand> >(); var transactionDecorator = new TransactionCommandHandler <TCommand>(commandHandler, diContainer); var logCommandDecorator = new LogCommandHandler <TCommand>(transactionDecorator); var exceptionDecorator = new ExceptionCommandHandler <TCommand>(logCommandDecorator); exceptionDecorator.Execute(command); }
public void DIBuilderTests_InterfaceBind() { IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <IClass1Test, Class1Test>().FromNew(); IDiContainer container = containerBuilder.Build(); IClass1Test class1Test = container.Resolve <IClass1Test>(); Assert.NotNull(class1Test); }
public void DIBuilderTests_FromFunction() { IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <Class1Test>().FromFunction((c) => new Class1Test()); IDiContainer container = containerBuilder.Build(); Class1Test class1Test = container.Resolve <Class1Test>(); Assert.IsNotNull(class1Test); }
private void ValidateDiContainer(DiImplementationType diImplementationType, IDiContainer diContainer) { // Validate resolutions in module DiModule1 Assert.AreEqual(diContainer.Resolve <IService1>().GetType(), typeof(Service1)); // Validate resolutions in native modules var interface1Test = diContainer.Resolve <ClassToTestServicesInjection <IInterface1> >(); switch (diImplementationType) { case DiImplementationType.Autofac: interface1Test.ValidateHasImplementation(typeof(Interface1_Impl1)); interface1Test.ValidateDoesNotHaveImplementation(typeof(Interface1_Impl2).FullName); break; case DiImplementationType.Ninject: interface1Test.ValidateHasImplementation(typeof(Interface1_Impl2)); interface1Test.ValidateDoesNotHaveImplementation(typeof(Interface1_Impl1).FullName); break; } }
public void ValidateOnIoCContainerLoaded(IDiContainer diContainer, ICustomAutoGeneratedServiceInfo customAutoGeneratedServiceInfo) { var settings = diContainer.Resolve <ISettings>(); if (settings.GetSettingValue <bool>("failCustomServiceValidation", false, out var failCustomServiceValidation)) { if (failCustomServiceValidation) { throw new Exception($"Validation {nameof(ValidateOnIoCContainerLoaded)} failed because the value of setting 'failCustomServiceValidation' is true"); } } }
/// <summary> /// Метод для получения данных из бд /// </summary> /// <typeparam name="T">Тип входных данных</typeparam> /// <returns>DbSet, содержащий элементы типа Note /// или CalendarEvent</returns> /// <exception cref="CreationException">CreationException</exception> /// <exception cref="ArgumentException">ArgumentException</exception> public object GetFromDatabase <T>() where T : class { if (typeof(T) == typeof(Note)) { using (var db = _container.Resolve <NoteContext>()) { var result = db.Notes; result.Load(); return(result.Local.ToList()); } } if (typeof(T) != typeof(CalendarEvent)) { throw new ArgumentException($"Invalid type {typeof(T)}"); } using (var db = _container.Resolve <CalendarEventContext>()) { IDictionary <Day, IList <CalendarEvent> > result = new Dictionary <Day, IList <CalendarEvent> >(); foreach (var day in db.Days.Include(e => e.Events)) { result.Add(day, day.Events); } return(result); } }
public void DIBuilderTests_FromInstance() { Class1Test classTest = new Class1Test(); IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <Class1Test>().FromInstance(classTest); IDiContainer container = containerBuilder.Build(); Class1Test class1Test = container.Resolve <Class1Test>(); Assert.IsNotNull(class1Test); }
public void DIBuilderTests_SimpleInit() { IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <Class3Test>() .FromNew() .WhenInit((o) => o.Init); IDiContainer container = containerBuilder.Build(); Class3Test class3Test = container.Resolve <Class3Test>(); Assert.IsNotNull(class3Test); }
public void Execute(TCommand command) { var unitOfWork = diContainer.Resolve <IUnitOfWork>(); try { commandHandler.Execute(command); unitOfWork.Commit(); } catch (Exception e) { unitOfWork.RollBack(); throw; } }
public void Execute(Tcommand command) { var unitOfWork = diContainer.Resolve <IUnitOfWork>(); try { handler.Execute(command); unitOfWork.Commit(); } catch { unitOfWork.Rollback(); throw; } }
public void DIBuilderTests_AssertCircularResolve() { IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <Class5Test>() .FromFunction((x) => new Class5Test( x.Resolve <Class6Test>() )); containerBuilder.Bind <Class6Test>() .FromFunction((x) => new Class6Test( x.Resolve <Class5Test>() )); IDiContainer container = containerBuilder.Build(); Assert.Throws <Exception>(() => container.Resolve <Class5Test>()); }
public void DIBuilderTests_MultipleContainersBind() { IDiContainerBuilder containerBuilder1 = new DiContainerBuilder(); containerBuilder1.Bind <Class1Test>().FromNew(); IDiContainer container1 = containerBuilder1.Build(); IDiContainerBuilder containerBuilder2 = new DiContainerBuilder(); containerBuilder2.Bind <Class2Test>() .FromFunction((c) => new Class2Test( c.Resolve <Class1Test>() )); containerBuilder2.Bind(container1); IDiContainer container2 = containerBuilder2.Build(); container2.Resolve <Class2Test>(); }
public void DIBuilderTests_SimpleDispose() { IDiContainerBuilder containerBuilder = new DiContainerBuilder(); containerBuilder.Bind <Class1Test>().FromNew(); containerBuilder.Bind <Class3Test>() .FromNew() .WhenDispose((o) => o.Dispose()); IDiContainer container = containerBuilder.Build(); Class3Test class3Test = container.Resolve <Class3Test>(); container.Dispose(); Assert.IsNotNull(class3Test); Assert.IsTrue(class3Test.Disposed); }
public void OnDiContainerReady(IDiContainer diContainer) { _diContainer = diContainer; _parameterSerializer = _diContainer.Resolve <ITypeBasedSimpleSerializerAggregator>(); }
public override object Resolve(Type type) => container.Resolve(type);
public object Resolve(Type resolveType) => container.Resolve(resolveType);
public IDiBindingActionBuilder <T> FromContainer(IDiContainer container) { return(FromFunction((c) => container.Resolve <T>())); }
public MainWindowViewModel(IDiContainer container) { _container = container; _container.Register <DataManager>(); _manager = _container.Resolve <DataManager>(parameters: new object[] { _container }); }
public override void Load() { foreach (var serviceBindingConfiguration in _module.ServiceBindingConfigurations) { if (serviceBindingConfiguration.RegisterIfNotRegistered && Kernel.GetBindings(serviceBindingConfiguration.ServiceType).Any()) { continue; } foreach (var implementationConfiguration in serviceBindingConfiguration.Implementations) { var ninjectServiceBindingConfiguration = Bind(serviceBindingConfiguration.ServiceType); IBindingWhenInNamedWithOrOnSyntax <object> ninjectImplementationConfiguration; switch (implementationConfiguration.TargetImplementationType) { case TargetImplementationType.Type: ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.To(implementationConfiguration.ImplementationType); break; case TargetImplementationType.Self: ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToSelf(); break; case TargetImplementationType.Delegate: ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToMethod(context => implementationConfiguration.ImplementationGeneratorFunction(_diContainer)); break; case TargetImplementationType.ProxiedType: ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToMethod(context => _diContainer.Resolve(implementationConfiguration.ImplementationType)); break; default: throw new Exception($"Unhandled value '{implementationConfiguration.TargetImplementationType}'."); } if (implementationConfiguration.WhenInjectedIntoType != null) { switch (implementationConfiguration.ConditionalInjectionType) { case ConditionalInjectionType.WhenInjectedInto: ninjectImplementationConfiguration.WhenInjectedInto(implementationConfiguration.WhenInjectedIntoType); break; case ConditionalInjectionType.WhenInjectedExactlyInto: ninjectImplementationConfiguration.WhenInjectedExactlyInto(implementationConfiguration.WhenInjectedIntoType); break; } } switch (implementationConfiguration.ResolutionScope) { case DiResolutionScope.Singleton: ninjectImplementationConfiguration.InSingletonScope(); break; case DiResolutionScope.Transient: ninjectImplementationConfiguration.InTransientScope(); break; case DiResolutionScope.ScopeLifetime: ninjectImplementationConfiguration.InScope(context => _diContainer.CurrentLifeTimeScope); break; //case DiResolutionScope.Thread: // ninjectImplementationConfiguration.InThreadScope(); // break; default: throw new Exception($"Unsupported resolution type.The value is '{implementationConfiguration.ResolutionScope}'."); } if (implementationConfiguration.OnImplementationObjectActivated != null) { ninjectImplementationConfiguration.OnActivation(activatedObject => implementationConfiguration.OnImplementationObjectActivated(_diContainer, activatedObject)); } } } }