public override void Prepare() { this.container = new IocContainer(); this.container.Register<ISingleton, Singleton>().WithLifetimeManager(new ContainerLifetime()); this.container.Register<ITransient, Transient>().WithLifetimeManager(new AlwaysNewLifetime()); this.container.Register<ICombined, Combined>().WithLifetimeManager(new AlwaysNewLifetime()); }
static MunqUseCase() { container = new IocContainer(); singleton = new Munq.LifetimeManagers.ContainerLifetime(); container.Register<IWebService>( c => new WebService( c.Resolve<IAuthenticator>(), c.Resolve<IStockQuote>())); container.Register<IAuthenticator>( c => new Authenticator( c.Resolve<ILogger>(), c.Resolve<IErrorHandler>(), c.Resolve<IDatabase>())); container.Register<IStockQuote>( c => new StockQuote( c.Resolve<ILogger>(), c.Resolve<IErrorHandler>(), c.Resolve<IDatabase>())); container.Register<IDatabase>( c => new Database( c.Resolve<ILogger>(), c.Resolve<IErrorHandler>())); container.Register<IErrorHandler>( c => new ErrorHandler(c.Resolve<ILogger>())); container.RegisterInstance<ILogger>(new Logger()) .WithLifetimeManager(singleton); }
public void CanSetDefaultLifetimeToSessionLifetime() { using (var container = new IocContainer(() => new SessionLifetime())) { Assert.IsInstanceOfType(container.DefaultLifetimeFactory(), typeof(SessionLifetime)); } }
public void TransientLifetimeAlwaysReturnsANewInstance() { // Arrange using (var container = new IocContainer()) { container.Register<IFoo>(c => new Foo1()); //.SetLifetime(new TransientLifetime<IFoo>); // Act var result1 = container.Resolve<IFoo>(); var result2 = container.Resolve<IFoo>(); var result3 = container.Resolve<IFoo>(); // Assert Assert.IsNotNull(result1); Assert.IsNotNull(result2); Assert.IsNotNull(result3); Assert.AreNotSame(result1, result2); Assert.AreNotSame(result2, result3); Assert.AreNotSame(result1, result3); Assert.IsInstanceOfType(result1, typeof(Foo1)); Assert.IsInstanceOfType(result2, typeof(Foo1)); Assert.IsInstanceOfType(result3, typeof(Foo1)); } }
public void TryResolveAllReturnsExpectedInstances() { using (var container = new IocContainer()) { // Arrange var foo1 = new Foo1(); var foo2 = new Foo2(); var foo3 = new Foo2(); var bar1 = new Bar1(); container.RegisterInstance<IFoo>(foo1); container.RegisterInstance<IFoo>(foo2, "Foo1"); container.RegisterInstance<IFoo>(foo3, "Foo2"); container.RegisterInstance<IBar>(bar1); // Act var results = container.TryResolveAll<IFoo>(); var resultList = results.ToList(); // Assert Assert.IsTrue(results.Count() == 3); CollectionAssert.Contains(resultList, foo1); CollectionAssert.Contains(resultList, foo2); CollectionAssert.Contains(resultList, foo3); } }
public void SessionLifetimeReturnsSameInstanceForSameSessionAndDifferentInstanceForDifferentSession() { // Arrange using (var container = new IocContainer()) { var sessionItems1 = new SessionStateItemCollection(); var sessionItems2 = new SessionStateItemCollection(); var context1 = new FakeHttpContext("Http://fakeUrl1.com", null, null, null, null, sessionItems1); var context2 = new FakeHttpContext("Http://fakeUrl2.com", null, null, null, null, sessionItems2); HttpContextBase currentContext = null; var lifetime = new SessionLifetime(() => currentContext); // better solution for injecting HttpContext ? container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime); // Act currentContext = context1; var result1 = container.Resolve<IFoo>(); var result2 = container.Resolve<IFoo>(); currentContext = context2; var result3 = container.Resolve<IFoo>(); // Assert Assert.IsNotNull(result1); Assert.IsNotNull(result2); Assert.IsNotNull(result3); Assert.AreSame(result1, result2); Assert.AreNotSame(result1, result3); } }
public void DefaultLifetimeIsDefaultSetToTransient() { using (var container = new IocContainer()) { Assert.IsInstanceOfType(container.DefaultLifetime, typeof(TransientLifetime)); } }
public void GenericResolveByTypeNotRegisteredThrowsException() { using (var container = new IocContainer()) { container.Resolve<IFoo>(); } }
public void Configuration(IAppBuilder appBuilder) { IIocContainer iocContainer = new IocContainer(); Bootstrap.Application() .ResolveReferencesWith(iocContainer) .UseEnvironment() .UseDomain().WithSimpleMessaging() .ConfigureRouteInspectorServer().WithRouteLimitOf(10) .ConfigureRouteInspectorWeb() .UseEventSourcing().PersistToMemory() .Initialise(); var configuration = new HttpConfiguration { DependencyResolver = new SystemDotDependencyResolver(iocContainer) }; configuration.MapHttpAttributeRoutes(); configuration.Filters.Add(new ModelStateContextFilterAttribute()); configuration.Filters.Add(new NoCacheFilterAttribute()); configuration.MapSynchronisationRoutes(); configuration.Routes.MapHttpRoute( "Default", "{controller}/{id}", new { id = RouteParameter.Optional }); appBuilder.UseWebApi(configuration); }
public void ThreadLocalStorageLifetimeReturnsSameInstanceForSameThread() { using (var container = new IocContainer()) { container.Register<IFoo>(c => new Foo1()).SetLifetime(new ThreadLocalLifetime()); IFoo result1 = container.Resolve<IFoo>(); IFoo result2 = container.Resolve<IFoo>(); IFoo result3 = null; IFoo result4 = null; // Resolve on a different thread var task = Task.Factory.StartNew(() => { result3 = container.Resolve<IFoo>(); result4 = container.Resolve<IFoo>(); }); task.Wait(); // Assert Assert.IsNotNull(result1); Assert.IsNotNull(result2); Assert.IsNotNull(result3); Assert.IsNotNull(result4); Assert.AreSame(result1, result2); Assert.AreSame(result3, result4); Assert.AreNotSame(result1, result3); } }
public void DefaultLifetimeMangerIsNull() { using (var iocContainer = new IocContainer()) { Assert.IsNull(iocContainer.DefaultLifetimeManager); } }
public void CanSetDefaultLifetimeToThreadLocalStorageLifetime() { using (var container = new IocContainer(() => new ThreadLocalLifetime())) { Assert.IsInstanceOfType(container.DefaultLifetimeFactory(), typeof(ThreadLocalLifetime)); } }
public void CanSetDefaultLifetimeToTransient() { using (var container = new IocContainer(() => new TransientLifetime())) { Assert.IsInstanceOfType(container.DefaultLifetime, typeof(TransientLifetime)); } }
public void GenericResolveByNameNotRegisteredThrowsException2() { using (var container = new IocContainer()) { container.Register<IFoo>(c => new Foo1()); container.Resolve<IFoo>("Foo"); } }
public override void PrepareBasic() { this.container = new IocContainer(); this.RegisterDummies(); this.RegisterStandard(); this.RegisterComplex(); }
protected void Application_Start() { IocContainer = new IocContainer(); AreaRegistration.RegisterAllAreas(); RegisterRoutes(RouteTable.Routes); }
public void GetServiceTest2() { var type = typeof(DefaultService1); var container = new IocContainer(); container.AddService(type, true); var childContainer = new IocContainer(container); Assert.Equal(childContainer.GetService(type), container.GetService(type)); }
public void AddService_TypeObjectBoolean_Test1() { var container = new IocContainer(); container.AddService(typeof(IService2), new XService2()); var childContainer = new IocContainer(container); Assert.IsAssignableFrom<XService2>(childContainer.GetService(typeof(IService2))); }
public void CanSetProvider() { var resolver = new IocContainer(); var locator = new DynamoServiceLocator(resolver); ServiceLocator.SetLocatorProvider(() => locator); // No way to get provider from ServiceLocator.Current to verify!! }
public void GetServiceTest1() { var itype = typeof(IService1); var container = new IocContainer(); Assert.False(container.ContainsService(itype)); Assert.NotNull(container.GetService(itype)); Assert.False(container.ContainsService(typeof(IService_NotFound))); Assert.Null(container.GetService(typeof(IService_NotFound))); }
public void ResolveAllByTypeNotRegisteredThrowsException() { using (var container = new IocContainer()) { var results = container.ResolveAll<IFoo>(); // Doesnt throw exception before it is enumerated because it uses yield return - OK ? var test = results.Count(); } }
public void CanSetDefaultLifetimeManagerToContainerLifetime() { using (var iocContainer = new IocContainer()) { var lifetime = new ContainerLifetime(); iocContainer.UsesDefaultLifetimeManagerOf(lifetime); Verify.That(iocContainer.DefaultLifetimeManager).IsTheSameObjectAs(lifetime); } }
void SettingTheDefaultContainerLifetime() { // create the container. Only done once in Application_Start IocContainer iocContainer = new IocContainer(); // create a lifetime manager to use as default ILifetimeManager lifetimeManager = new LifetimeManagers.RequestLifetime(); // set the default lifetime manager iocContainer.UsesDefaultLifetimeManagerOf(lifetimeManager); }
static MunqGenericUseCase() { container = new IocContainer(); //container.Register<IWebService, WebService>(); container.Register<IAuthenticator, Authenticator>(); container.Register<IStockQuote, StockQuote>(); container.Register<IDatabase, Database>(); container.Register<IErrorHandler, ErrorHandler>(); container.Register<ILogger,Logger>().WithLifetimeManager(singleton); }
/// <summary> /// Initialize method called from XDMessaging.Core before the instance is constructed. /// This allows external classes to registered dependencies with the IocContainer. /// </summary> /// <param name = "container">The IocContainer instance used to construct this class.</param> private static void Initialize(IocContainer container) { Validate.That(container).IsNotNull(); container.Register(AmazonAccountSettings.GetInstance, LifeTime.Singleton); container.Register<ITopicRepository, TopicRepository>(LifeTime.Singleton); container.Register<ISubscriberRepository, SubscriberRepository>(LifeTime.Singleton); container.Register<IQueuePoller, QueuePoller>(LifeTime.Singleton); container.Register<IAmazonSqsFacade, AmazonSqsFacade>(LifeTime.Singleton); container.Register<IAmazonSnsFacade, AmazonSnsFacade>(LifeTime.Singleton); }
public void GenericResolveByTypeReturnsInstanceOfExpectedType() { using (var container = new IocContainer()) { container.Register<IFoo>(c => new Foo1()); var result = container.Resolve<IFoo>(); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IFoo)); Assert.IsInstanceOfType(result, typeof(Foo1)); } }
public void TestRegisterSingletonClass() { var container = new IocContainer(); container.Register(typeof(ConnectionName), LifestyleType.Singleton); ConnectionName connectionName = (ConnectionName)container.Resolve(typeof(ConnectionName)); Assert.NotNull(connectionName); ConnectionName connectionName2 = (ConnectionName)container.Resolve(typeof(ConnectionName)); Assert.NotNull(connectionName); Assert.Equal(connectionName, connectionName2); }
public void RunBeforeAnyTests() { //NHibernateProfiler.Initialize(); Container = new IocContainer(); Fac.Default.Interceptors.Add(t => new HardenInterceptor()); { Fac.Default.SetServiceLocator(Container.Resolve, Container.CanResolve); } NHibernateConfigurator.Configure(Container, new ThreadLocalStorageLifetime()); }
public void TestRegisterSingletonClassGeneric() { var container = new IocContainer(); container.Register<ConnectionName>(LifestyleType.Singleton); ConnectionName connectionName = container.Resolve<ConnectionName>(); Assert.NotNull(connectionName); ConnectionName connectionName2 = container.Resolve<ConnectionName>(); Assert.NotNull(connectionName); Assert.Equal(connectionName, connectionName2); }
public void TryResolveByTypeNotRegisteredReturnsFalseAndNull() { using (var container = new IocContainer()) { // Act IFoo obj; bool result = container.TryResolve<IFoo>(out obj); // Assert Assert.IsFalse(result); Assert.IsNull(obj); } }
public void CanResolve() { IocContainer.Resolve <ISingleZipCodeProcessor>().Should().NotBeNull(); IocContainer.Resolve <IPersistenceInitializer>().Should().NotBeNull(); IocContainer.Resolve <IZipCodeUrlSerializer>().Should().NotBeNull(); IocContainer.Resolve <IStoreInfoResponseDataService>().Should().NotBeNull(); IocContainer.Resolve <IZipCodeDataService>().Should().NotBeNull(); IocContainer.Resolve <IAllZipCodesProcessor>().Should().NotBeNull(); IocContainer.Resolve <IDelaySimulator>().Should().NotBeNull(); IocContainer.Resolve <ICacheWithExpiration>().Should().NotBeNull(); IocContainer.Resolve <IStorePersistenceCalculator>().Should().NotBeNull(); IocContainer.Resolve <ITimerFactory>().Should().NotBeNull(); ValidateSingletonRegistration <IMemoryCache>(); }
public virtual void Start() { Initialize(); if (!MvvmApplication.Context.Contains(NavigationConstants.IsDialog)) { MvvmApplication.Context.Add(NavigationConstants.IsDialog, false); } var rootPresenter = GetRootPresenter(); if (rootPresenter != null) { IocContainer.Get <IViewModelPresenter>().DynamicPresenters.Add(rootPresenter); } MvvmApplication.Start(); }
public void TestCycleInClassesBoundByInterfaceTakingInterfaceTypes() { var ioc = new IocContainer(); ioc.Bind <ICyclicA, CyclicAThroughInterface>(); ioc.Bind <ICyclicB, CyclicBThroughInterface>(); Assert.ThrowsException <ActivationException>( () => ioc.Resolve <ICyclicA>() ); Assert.ThrowsException <ActivationException>( () => ioc.Resolve <ICyclicB>() ); }
public void TestRegisterTransientClassGeneric() { var container = new IocContainer(); container.Register <ConnectionName>(); ConnectionName connectionName = container.Resolve <ConnectionName>(); Assert.NotNull(connectionName); ConnectionName connectionName2 = container.Resolve <ConnectionName>(); Assert.NotNull(connectionName); Assert.NotEqual(connectionName, connectionName2); }
protected override bool LoadInternal() { #if DEBUG IocContainer.Bind <ICurrentWeatherDataProvider, FakeCurrentWeatherDataProvider>(DependencyLifecycle.SingleInstance); //IocContainer.Bind<ICurrentWeatherDataProvider, NarodMonWeatherDataProvider>(DependencyLifecycle.SingleInstance); IocContainer.Bind <IWeatherForecastDataProvider, FakeWeatherForecastDataProvider>(DependencyLifecycle.SingleInstance); //IocContainer.Bind<IWeatherForecastDataProvider, Rp5WeatherForecastDataProvider>(DependencyLifecycle.SingleInstance); #else IocContainer.Bind <ICurrentWeatherDataProvider, NarodMonWeatherDataProvider>(DependencyLifecycle.SingleInstance); IocContainer.Bind <IWeatherForecastDataProvider, Rp5WeatherForecastDataProvider>(DependencyLifecycle.SingleInstance); #endif return(true); }
private static void RegisterPropertyProviders(IServiceCollection services) { var iocContainer = new IocContainer(services); ImmoscoutProviderBootstrapper.Register(iocContainer); ImmoscoutListProviderBootstrapper.Register(iocContainer); ImmoXXLProviderBootstrapper.Register(iocContainer); ImmosuchmaschineProviderBoostrapper.Register(iocContainer); KskProviderBootstrapper.Register(iocContainer); OhneMaklerProviderBoostrapper.Register(iocContainer); VolksbankFlowfactProviderBootstrapper.Register(iocContainer); VolksbankImmopoolProviderBootstrapper.Register(iocContainer); WunschimmoProviderBootstrapper.Register(iocContainer); ZvgProviderBootstrapper.Register(iocContainer); }
public void AddService_TypeBooleanBoolean_Test1() { var type = typeof(DefaultService1); var itype = typeof(IService1); var container = new IocContainer(); container.AddService(type); Assert.NotNull(container.GetService(type)); Assert.NotNull(container.GetService(itype)); Assert.NotEqual(container.GetService(type), container.GetService(type)); Assert.NotEqual(container.GetService(type), container.GetService(itype)); Assert.IsAssignableFrom(type, container.GetService(itype)); }
protected virtual IDynamicViewModelPresenter GetRootPresenter() { if (RootPresenterFactory != null) { return(RootPresenterFactory(IocContainer)); } if (WrapToNavigationController) { return(null); } var presenter = IocContainer.Get <TouchRootDynamicViewModelPresenter>(); presenter.Window = Window; return(presenter); }
public void CanCreateSimpleTypeWithOneParameterUsingFactoryMethod() { var container = new IocContainer(); container.Register(() => new MySimpleThing() { MyName = "MyNameIsBob" }); container.Register <MySlightlySimpleThing>(); var mySlightlySimpleThing = container.Resolve <MySlightlySimpleThing>(); mySlightlySimpleThing.Should().NotBeNull(); mySlightlySimpleThing.SimpleThing.Should().NotBeNull(); mySlightlySimpleThing.SimpleThing.MyName.Should().Be("MyNameIsBob"); }
public void TestRegisterSingletonClassGeneric() { var container = new IocContainer(); container.Register <ConnectionName>(LifestyleType.Singleton); ConnectionName connectionName = container.Resolve <ConnectionName>(); Assert.NotNull(connectionName); ConnectionName connectionName2 = container.Resolve <ConnectionName>(); Assert.NotNull(connectionName); Assert.Equal(connectionName, connectionName2); }
public void NamedTypeWithParametersRegistrationResolvesToCorrectType() { using (var container = new IocContainer()) { container.Register <IFoo, Foo1>(); container.Register <IBar, Bar1>(); container.Register <IFooBar, FooBar>("bob"); IFooBar result = container.Resolve <IFooBar>("bob"); Verify.That(result).IsNotNull().IsAnInstanceOfType(typeof(FooBar)); Verify.That(result.foo).IsNotNull().IsAnInstanceOfType(typeof(Foo1)); Verify.That(result.bar).IsNotNull().IsAnInstanceOfType(typeof(Bar1)); } }
private async void OnRequestHomePage(HomeViewModel hVm) { //Did Load will assign through Actions to Post view models, we need to assign this action early, but it is safe due to shared services hVm.RequestCommentPage = OnRequestCommentPage; if (_viewModel == null && IocContainer.GetContainer().Resolve <ITwitterApi>().GetType() == typeof(MockTwitterApi)) { await Task.Delay(5000); } await hVm.DidLoad(); //TODO add back in the grow animation _navigationService.NavigateTo(ViewModelLocator.HOME_KEY, hVm, null, Shared.Common.AnimationFlag.Grow); }
public void TestRegisterTransientClass() { var container = new IocContainer(); container.Register(typeof(ConnectionName)); ConnectionName connectionName = (ConnectionName)container.Resolve(typeof(ConnectionName)); Assert.NotNull(connectionName); ConnectionName connectionName2 = (ConnectionName)container.Resolve(typeof(ConnectionName)); Assert.NotNull(connectionName); Assert.NotEqual(connectionName, connectionName2); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); IocContainer.Setup(); //AreaRegistration.RegisterAllAreas(); //RegisterGlobalFilters(GlobalFilters.Filters); //RegisterRoutes(RouteTable.Routes); //// Add this line to Application_Start in Global.asax.cs to setup the IoC Container. //IocContainer.Setup(); }
public void TestGetAllInstances() { var ioc = new IocContainer(); var inst1 = new Concrete(); var inst2 = new Concrete(); ioc.Bind <ITest>(() => inst1); ioc.Bind <ITest>("key", () => inst2); IServiceLocator locator = ioc; object[] instances = locator.GetAllInstances(typeof(ITest)).ToArray(); CollectionAssert.AreEqual(new[] { inst1, inst2 }, instances); }
void SettingTheLifetimeManagerForARegistration() { // create the container. Only done once in Application_Start IocContainer iocContainer = new IocContainer(); // create a Container lifetime manager to use for 'singelton' services // only one instance will be created and reused for each resolve request. ILifetimeManager containerLifetimeManager = new LifetimeManagers.ContainerLifetime(); iocContainer.Register <IMembershipService>(ioc => new AccountMembershipService(Membership.Provider)) .WithLifetimeManager(containerLifetimeManager); iocContainer.Register <IFormsAuthenticationService>(ioc => new FormsAuthenticationService()) .WithLifetimeManager(containerLifetimeManager); }
public ICommandExecutorContainer RegisterExecutor <TExecutor>() where TExecutor : class, ICommandExecutor { var executor = IocContainer.Resolve <TExecutor>(); var executorConfig = new CommandExecutorConfig(executor); CheckExecutorConfigDuplicate(executorConfig); _executorConfigs.Add(executorConfig); if (_dbContext == null) { _dbContext = executor.DbContext; } return(this); }
public void RegisterInstanceGenericReturnsCorrectType() { using (var container = new IocContainer()) { var fooInstance = new Foo1(); var reg = container.RegisterInstance <IFoo>(fooInstance); Assert.IsInstanceOfType(reg, typeof(InstanceRegistration <IFoo>)); Assert.AreSame(reg.ReturnType, typeof(IFoo)); // Check index Assert.IsTrue(container.Index.Contains(typeof(IFoo))); } }
public void RegisterInstanceUsingKeyReturnsCorrectType() { using (var container = new IocContainer()) { var fooInstance = new Foo1(); var result = container.RegisterInstance(typeof(IFoo), fooInstance, "Bar"); Assert.IsInstanceOfType(result, typeof(InstanceRegistration <IFoo>)); Assert.AreSame(result.ReturnType, typeof(IFoo)); // Check index Assert.IsTrue(container.Index.Contains(typeof(IFoo), "Bar")); } }
public void NonGenericNamelessLazyResolveReturnsDelegateReturningObjectOfExpectedType() { using (var iocContainer = new IocContainer()) { iocContainer.Register(typeof(IFoo), c => new Foo1()); var result = iocContainer.LazyResolve(typeof(IFoo)); Verify.That(result) .IsNotNull() .IsAnInstanceOfType(typeof(Func <object>)); Verify.That(result()) .IsAnInstanceOfType(typeof(Foo1)); } }
public void GetRegistrationsReturnsAnEmptyListIfNoRegistrationsOfTheRequesetedType() { using (var iocContainer = new IocContainer()) { iocContainer.Register <IFoo>(c => new Foo1()); iocContainer.Register <IFoo>("Bob", c => new Foo2()); iocContainer.Register <IFoo>("Bill", c => new Foo2()); var result = iocContainer.GetRegistrations <IBar>(); Verify.That(result.ToList()).IsACollectionThat() .IsAnInstanceOfType(typeof(List <IRegistration>)) .Count().IsEqualTo(0); } }
public void UsesDefaultLifetimeManagerOfChangesTheDefaultLifetimeManager() { using (var iocContainer = new IocContainer()) { var aLifetimeManager = new LifetimeManagers.ContainerLifetime(); iocContainer.UsesDefaultLifetimeManagerOf(aLifetimeManager); iocContainer.Register <IFoo>(c => new Foo1()); var foo1 = iocContainer.Resolve <IFoo>(); var foo2 = iocContainer.Resolve <IFoo>(); Verify.That(iocContainer.DefaultLifetimeManager).IsTheSameObjectAs(aLifetimeManager); Verify.That(foo1).IsTheSameObjectAs(foo2); } }
public override IWindow Initialize(EventArgs e = null) { // MainWindow event subscriptions MainWindow.configEdit.TextArea.TextEntered += TextArea_TextEntered; MainWindow.configEdit.TextArea.TextEntering += TextArea_TextEntering; MainWindow.queryEdit.TextArea.TextEntered += TextArea_TextEntered; MainWindow.queryEdit.TextArea.TextEntering += TextArea_TextEntering; MainWindow.grdMainData.AutoGeneratingColumn += DataGrid_AutoGeneratingColumn; MainWindow.KeyDown += MainWindow_KeyDown; // When the view is loaded we'll invoke the ReadCsvCommand in case the user // double clicked a file, the null lets command now we were not a button click MainWindow.Loaded += (s, para) => { InvokeCommand(ReadCsvCommand.CommandName, null); // Bind F5-F6 key to execute commands var queryCommand = IocContainer.Resolve <ICommand>(QueryCommand.CommandName); var resetQueryCommand = IocContainer.Resolve <ICommand>(ResetQueryCommand.CommandName); var f5 = new InputBinding(queryCommand, new KeyGesture(Key.F5)); MainWindow.InputBindings.Add(f5); var f6 = new InputBinding(resetQueryCommand, new KeyGesture(Key.F6)); MainWindow.InputBindings.Add(f6); }; MainWindow.Closed += MainWindow_Closed; MainViewModel.ErrorMessages.CollectionChanged += (_, __) => MainViewModel.HasErrorMessages = MainViewModel.ErrorMessages.Count > 0; MainViewModel.Host = IocContainer.Resolve <CsvEditSharpConfigurationHost>(); IocContainer.RegisterInstance <ICsvEditSharpConfigurationHost>(MainViewModel.Host); IocContainer.RegisterInstance <IList <string> >(MainViewModel.ErrorMessages); MainViewModel.Workspace = IocContainer.Resolve <CsvEditSharpWorkspace>(); MainViewModel.ConfigurationDoc = new TextDocument(StringTextSource.Empty); MainViewModel.QueryDoc = new TextDocument(new StringTextSource("Query<FieldData>( records => records.Where(row => true));")); MainViewModel.CurrentFilePath = string.Empty; MainViewModel.CurrentFileName = "(Empty)"; MainViewModel.CurrentConfigName = "(Empty)"; MainViewModel.SelectedTemplate = MainViewModel.ConfigFileTemplates.First(); MainViewModel.SelectedTab = 0; return(MainWindow); }
public DataResult <Transfer> CreateTransferSINSIN(int character, [FromBody] CreateTransferSinSinRequest request) { var manager = IocContainer.Get <IBillingManager>(); DataResult <Transfer> result; if (string.IsNullOrEmpty(request.SinTo)) { result = RunAction(() => manager.MakeTransferSINSIN(character, request.CharacterTo, request.Amount, request.Comment), "transfer/createtransfersinsin"); } else { result = RunAction(() => manager.MakeTransferSINSIN(character, request.SinTo, request.Amount, request.Comment), $"transfer/createtransfersinsin {character}=>{request.SinTo}:{request.Amount}"); } return(result); }
public void IsTurnCompleteGermainYes() { IocContainer.Setup(); UnitList units = new UnitList(new BattleCalculator(new DieRoller()), new TerrainMap(new ShortestPath())); units.Add(2, 2, 0, NATIONALITY.Germany); units.Add(3, 3, 0, NATIONALITY.USA); units.Add(4, 4, 0, NATIONALITY.Germany); units[0].Movement = 0; units[0].UnitHasAttackedThisTurn = true; units[2].Movement = 0; units[2].UnitHasAttackedThisTurn = true; Assert.True(units.IsTurnComplete(NATIONALITY.Germany)); }
public void Resolve_VeryComplexNotSameInstanceFromContainer2() { // test of resolving a type that has dependent parameter types // to see if the instance is transient IMyContainer container = new IocContainer(); container.Register <System.Xml.XmlDocument, System.Xml.XmlDocument>(LifeCycle.Singleton); container.Register <StringBuilder, StringBuilder>(LifeCycle.Singleton); container.Register <VeryComplexType, VeryComplexType>(); VeryComplexType expected = container.Resolve <VeryComplexType>(); VeryComplexType actual = container.Resolve <VeryComplexType>(); Assert.NotSame(expected, actual); }
public void RemoveServiceTest2() { var container = new IocContainer(); var childContainer = new IocContainer(container); var itype = typeof(IService2); childContainer.Add(itype, lmp => new XService2(), promote: true); Assert.True(container.Contains(itype)); Assert.True(childContainer.Contains(itype)); container.Add(itype, lmp => new DefaultService2()); Assert.IsAssignableFrom <XService2>(childContainer.Get(itype)); Assert.IsAssignableFrom <DefaultService2>(container.Get(itype)); childContainer.Remove(itype, true); Assert.False(container.Contains(itype)); Assert.False(childContainer.Contains(itype)); }
public async void should_resolve_from_thread_static() { var container = new IocContainer(); container.Register <IDummyType>(iocContainer => { return(ThreadIndependentResolver <IDummyType> .instance ?? (ThreadIndependentResolver <IDummyType> .instance = new DummyType())); }); var instance = container.Resolve <IDummyType>(); var threadedInstance = await Task.Run(() => { return(container.Resolve <IDummyType>()); }); Assert.NotEqual(instance, threadedInstance); }
public void TestConfigure() { var ioc = new IocContainer(); ioc.Configure(new TestOptions { IntValue = 5, StringValue = "TEST", }); var svc = ioc.Resolve <TestService>(); Assert.IsNotNull(svc.Configuration.Value); Assert.AreEqual(5, svc.Configuration.Value.IntValue); Assert.AreEqual("TEST", svc.Configuration.Value.StringValue); }