public void CanSafelyDisposeContainerTwice() { DisposableExtension extension = new DisposableExtension(); IUnityContainer container = new UnityContainer() .AddExtension(extension); container.Dispose(); container.Dispose(); }
/// <summary> /// Invoked when the application is launched normally by the end user. Other entry points /// will be used such as when the application is launched to open a specific file. /// </summary> /// <param name="e">Details about the launch request and process.</param> protected override void OnLaunched(LaunchActivatedEventArgs e) { var assembly = Assembly.Load(new AssemblyName(nameof(CheckersUI))); _container?.Dispose(); _container = new UnityContainer(); _container.RegisterTypes(assembly.GetTypes(), getLifetimeManager: WithLifetime.ContainerControlled); var gamePage = _container.Resolve <GamePage>(); gamePage.DataContext = _container.Resolve <GamePageViewModel>(); var boardEditor = _container.Resolve <BoardEditor>(); var parameterInjection = new ParameterOverride("board", Board.DefaultBoard(Variant.AmericanCheckers)); boardEditor.DataContext = _container.Resolve <BoardEditorViewModel>(parameterInjection); var rules = _container.Resolve <Rules>(); rules.DataContext = _container.Resolve <RulesViewModel>(); var mainPage = _container.Resolve <MainPage>(new ParameterOverride("initialView", gamePage)); #if DEBUG if (System.Diagnostics.Debugger.IsAttached) { DebugSettings.EnableFrameRateCounter = true; } #endif var rootFrame = Window.Current.Content as Frame; // Do not repeat app initialization when the Window already has content, // just ensure that the window is active if (rootFrame == null) { // Create a Frame to act as the navigation context and navigate to the first page rootFrame = _container.Resolve <Frame>(); rootFrame.NavigationFailed += OnNavigationFailed; if (e.PreviousExecutionState == ApplicationExecutionState.Terminated) { //TODO: Load state from previously suspended application } // Place the frame in the current Window Window.Current.Content = rootFrame; } if (!e.PrelaunchActivated) { if (rootFrame.Content == null) { rootFrame.Content = mainPage; } Window.Current.Activate(); } }
public virtual void TestCleanup() { Container?.Dispose(); var disposable = Sut as IDisposable; disposable?.Dispose(); }
public void DisposableExtensionsAreDisposedWithContainerButNotRemoved() { DisposableExtension extension = new DisposableExtension(); IUnityContainer container = new UnityContainer() .AddExtension(extension); container.Dispose(); Assert.IsTrue(extension.Disposed); Assert.IsFalse(extension.Removed); }
public void AfterDisposingTheContainerTheServiceLocatorCanResolved() { UnityContainer container = GetNewContainer(); IServiceLocator sl = new UnityServiceLocator(container); container.RegisterType <IService, Service>(); AssertEx.ShouldNotThrow(() => sl.GetInstance <IService>()); container.Dispose(); AssertEx.ShouldNotThrow(() => sl.GetInstance <IService>()); }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { container.Dispose(); } disposedValue = true; } }
public void GetObjectAfterDispose() { UnityContainer parent = new UnityContainer(); parent.RegisterType <Temp>("First", new ContainerControlledLifetimeManager()); IUnityContainer child = parent.CreateChildContainer(); child.RegisterType <ITemporary>("First", new ContainerControlledLifetimeManager()); parent.Dispose(); AssertHelper.ThrowsException <ResolutionFailedException>(() => child.Resolve <ITemporary>("First")); }
public void DisposingParentDisposesChild() { UnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); DisposableObject spy = new DisposableObject(); child.RegisterInstance <DisposableObject>(spy); parent.Dispose(); Assert.True(spy.WasDisposed); }
static void Main(string[] args) { var container = new UnityContainer(); container.RegisterType <Foo>(new ContainerControlledLifetimeManager()); var foo = container.Resolve <Foo>(); container.Dispose(); Console.ReadKey(); }
public void DisposingContainerDisposesSingletons() { IUnityContainer container = new UnityContainer() .RegisterType <DisposableObject>(new ContainerControlledLifetimeManager()); DisposableObject dobj = container.Resolve <DisposableObject>(); Assert.IsFalse(dobj.WasDisposed); container.Dispose(); Assert.IsTrue(dobj.WasDisposed); }
public void WhenDisposingParentChildDisposes() { IUnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); TestContainer3 obj = new TestContainer3(); child.RegisterInstance <TestContainer3>(obj); parent.Dispose(); Assert.IsTrue(obj.WasDisposed); }
public override Image ProcessImage(Image input, ProjectSetting ps) { try { if (ps.ShrinkPixelTo > 0) { IUnityContainer container = new UnityContainer(); //container.RegisterType<IResize, ResizeByLongSide>("LongSide", new PerThreadLifetimeManager()); //container.RegisterType<IResize, ResizeByWidth>("Width", new PerThreadLifetimeManager()); //container.RegisterType<IResize, ResizeByHeight>("Height", new PerThreadLifetimeManager()); container.RegisterType <IResize, ResizeByLongSide>("LongSide", new ContainerControlledLifetimeManager()); container.RegisterType <IResize, ResizeByWidth>("Width", new ContainerControlledLifetimeManager()); container.RegisterType <IResize, ResizeByHeight>("Height", new ContainerControlledLifetimeManager()); IResize resize = null; switch (ps.ShrinkMode) { case ShrinkImageMode.Height: resize = container.Resolve <IResize>("Height"); break; case ShrinkImageMode.Width: resize = container.Resolve <IResize>("Width"); break; case ShrinkImageMode.LongSide: resize = container.Resolve <IResize>("LongSide"); break; } container.Dispose(); if (resize != null) { System.Windows.Size currentSize = new System.Windows.Size((double)input.Width, (double)input.Height); System.Windows.Size newSize = resize.CalculateNewSize(currentSize, (double)ps.ShrinkPixelTo); return(ResizeImageJob(input, newSize, InterpolationMode.HighQualityBicubic)); } else { return(input); } } else { // if no new size is specified, don't do the job. return(input); } } catch (Exception ex) { Trace.TraceError(ex.ToString()); return(input); } }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { // If disposing equals true, dispose all managed and unmanaged resources. if (disposing) { // Dispose managed resources. if (container != null) { container.Dispose(); } container = null; } }
public void OnlyDisposableExtensionAreDisposed() { DisposableExtension extension = new DisposableExtension(); NoopExtension noop = new NoopExtension(); IUnityContainer container = new UnityContainer() .AddExtension(noop) .AddExtension(extension); container.Dispose(); Assert.IsTrue(extension.Disposed); }
public void DependencyContainer_ContainerRegistration_ServiceResolvbable() { //Setup IUnityContainer container = new UnityContainer(); //Act foreach (var registration in container.Registrations) { //Assert Assert.IsNotNull(container.Resolve(registration.RegisteredType, registration.Name)); } container.Dispose(); }
// #region Test Infrastructure Code // // This property contains a function to call to write to the console // public Action<string> WriteLine { get; private set; } // // // This property contains a function to call to read a string from the console // public Func<string> ReadLine { get; private set; } // // // Store the methods that perform the WriteLine and ReadLines to the console // public MainClass(Action<string> writeLine, Func<string> readLine) // { // ReadLine = readLine; // WriteLine = writeLine; // } // #endregion public static void Main(string[] args) { var container = new UnityContainer(); container.RegisterInstance <IConsole>(new DefaultConsole()); container.RegisterType <ISummarizer, DefaultSummarizer>(); var program = container.Resolve <MainClass>(); program.Run(); container.Dispose(); }
protected virtual void Dispose(bool disposing) { if (disposing) { UnregisterMandatoryDependencies(); if (_unityContainer != null) { _unityContainer.Dispose(); _unityContainer = null; } } }
public void AfterDisposingTheContainerAndTheServiceLocatorResultsInObjectDisposedExceptionWhenResolving() { UnityContainer container = GetNewContainer(); IServiceLocator sl = new UnityServiceLocator(container); container.RegisterType <IService, Service>(); AssertEx.ShouldNotThrow(() => sl.GetInstance <IService>()); container.Dispose(); ((IDisposable)sl).Dispose(); AssertEx.ShouldThrow(() => sl.GetInstance <IService>()); }
public void ContainerControlledOpenGenericsAreDisposed() { var container = new UnityContainer() .RegisterType(typeof(ICommand <>), typeof(DisposableCommand <>), new ContainerControlledLifetimeManager()); var accountCommand = container.Resolve <ICommand <Account> >(); var userCommand = container.Resolve <ICommand <User> >(); container.Dispose(); Assert.IsTrue(((DisposableCommand <Account>)accountCommand).Disposed); Assert.IsTrue(((DisposableCommand <User>)userCommand).Disposed); }
static void Main() { Log4NetLogger.Use("cashier.log4net.xml"); var container = new UnityContainer(); // register types directly container.RegisterType <CashierService>(new ContainerControlledLifetimeManager()); container.RegisterType(typeof(ISagaRepository <>), typeof(InMemorySagaRepository <>), new ContainerControlledLifetimeManager()); // Register the ServiceBus. container.RegisterInstance <IServiceBus>(ServiceBusFactory.New(sbc => { // Configure exchanges. sbc.ReceiveFrom("msmq://localhost/starbucks_cashier"); sbc.UseMsmq(); sbc.UseMulticastSubscriptionClient(); sbc.SetConcurrentConsumerLimit(1); //a cashier cannot multi-task sbc.UseControlBus(); sbc.EnableRemoteIntrospection(); sbc.Subscribe(subs => { subs.LoadFrom(container); }); })); HostFactory.Run(c => { c.SetServiceName("StarbucksCashier"); c.SetDisplayName("Starbucks Cashier"); c.SetDescription("a Mass Transit sample service for handling orders of coffee.."); c.DependsOnMsmq(); c.RunAsLocalService(); DisplayStateMachine(); c.Service <CashierService>(s => { s.ConstructUsing(builder => container.Resolve <CashierService>()); s.WhenStarted(o => o.Start()); s.WhenStopped(o => { o.Stop(); container.Dispose(); }); }); }); }
/// <summary> /// Builds and configures a new Unity container. /// </summary> /// <returns>A configured Unity container</returns> public IUnityContainer Resolve() { var unityContainer = new UnityContainer(); try { RegisterDependencies(unityContainer); } catch (Exception) { unityContainer.Dispose(); throw; } return(unityContainer); }
private bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // TODO: dispose managed state (managed objects). uc.Dispose(); } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. // TODO: set large fields to null. disposedValue = true; } }
public void CanRegisterDefaultInstanceWithoutLifetimeViaGenericMethod() { DisposableObject o = new DisposableObject(); IUnityContainer container = new UnityContainer() .RegisterInstance <object>(o, new ExternallyControlledLifetimeManager()); object result = container.Resolve <object>(); Assert.IsNotNull(result); Assert.AreSame(o, result); container.Dispose(); Assert.IsFalse(o.WasDisposed); GC.KeepAlive(o); }
static void TestUnityContainer() { IUnityContainer container = new UnityContainer(); container.RegisterType <IHelloService, HiService>(); using (IUnityContainer child = container.CreateChildContainer()) { child.RegisterType <IMessageWriter, TextMessageWriter>(); PrintRegistrations(container); PrintRegistrations(child); } PrintRegistrations(container); container.Dispose(); }
public void DisposeContainerDisposesCachedParsley() { var container = new UnityContainer(); var lease = new SlidingLease(TimeSpan.FromMinutes(1)); var cache = new CacheLifetimeManager(lease); container.RegisterType <IIngredient, Parsley>(cache); var ingredient = container.Resolve <IIngredient>(); container.Dispose(); var parsley = Assert.IsAssignableFrom <Parsley>(ingredient); Assert.True(parsley.IsDisposed); }
public override ScenarioInstance <ContainerConfiguration> CreateInstance() { var unityContainer = new UnityContainer(); var configuration = new ContainerConfiguration { ApplyContainerDefaults = bbc => { unityContainer.RegisterNimbus(bbc.TypeProvider); return(bbc.WithUnityDependencyResolver(unityContainer)); } }; var instance = new ScenarioInstance <ContainerConfiguration>(configuration); instance.Disposing += (s, e) => unityContainer.Dispose(); return(instance); }
private static IUnityContainer BuildContainer(string[] args) { // BOOKMARK: 5.2 Unity var container = new UnityContainer(); try { var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .AddCommandLine(args); var configuration = configBuilder.Build(); // Configure options container .AddExtension(new OptionsExtension()) .Configure <PriceProviderOptions>(configuration.GetSection("PriceProvider")); // A new instance per dependency container.RegisterType <ICompanyPriceProvider, CompanyPriceProvider>(); container.RegisterType <ICompanyService, CompanyService>(); container.RegisterType <IPriceProvider, PriceProvider>(); container.RegisterType <ICompanyRepository, DbCompanyRepository>(); container.RegisterType <IStockRepository, DbStockRepository>(); // A single instance per a child container (scope) container.RegisterType <IDbConnection, FakeDbConnection>(new HierarchicalLifetimeManager()); // See difference with HierarchicalLifetimeManager - it's actually singleton //container.RegisterType<IDbConnection, FakeDbConnection>(new ContainerControlledLifetimeManager()); // Note, that, unlike in other containers, you MUST register using ContainerControlledTransientManager, // ContainerControlledLifetimeManager or HierarchicalLifetimeManager if you want Unity to dispose your instances. // See https://github.com/unitycontainer/unity/wiki/Unity-Lifetime-Managers for more information // Single instance container.RegisterSingleton <ILogger, ConsoleLogger>(); } catch { container.Dispose(); throw; } return(container); }
public void DisposingUnityDisposesCompositionContainerTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddNewExtension <CompositionIntegration>(); unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog); var compositionContainer = unityContainer.Resolve <CompositionContainer>(); unityContainer.Dispose(); Assert.That(delegate { compositionContainer.GetExport <IMefComponent>(); }, Throws.TypeOf <ObjectDisposedException>()); }
public void HandCodeUnityTest() { IUnityContainer container = new UnityContainer(); container.RegisterType <IProductService, ProductService>(); var ids = new List <Guid>(); for (int i = 0; i < 1000; i++) { var product = container.Resolve <IProductService>(); } ids = null; container.Dispose(); container = null; Trace.WriteLine("Game over--------------------------------------"); GC.Collect(); //Thread.Sleep(10000); }
static void Main(string[] args) { while (Console.ReadKey().Key != ConsoleKey.Escape) { var container = new UnityContainer(); //Hard code mapping //container.RegisterType<IVersionable, AssemblyV1>(); //Configuarion Mapping ConfigurationManager.RefreshSection("unity"); var section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");; container.LoadConfiguration(section); MainAssembly assembly = container.Resolve <MainAssembly>(); Console.WriteLine(string.Format("Your Assembly Version is {0}", assembly.Version.GetVersion())); Console.WriteLine("Press Any Key to Call Assembly Again or Press Escape to Exit..."); container.Dispose(); } }
public void CanDisposeChildWithoutDisposingParent() { DisposableObject parentSpy = new DisposableObject(); DisposableObject childSpy = new DisposableObject(); UnityContainer parent = new UnityContainer(); parent.RegisterInstance(parentSpy); IUnityContainer child = parent.CreateChildContainer() .RegisterInstance(childSpy); child.Dispose(); Assert.False(parentSpy.WasDisposed); Assert.True(childSpy.WasDisposed); childSpy.WasDisposed = false; parent.Dispose(); Assert.True(parentSpy.WasDisposed); Assert.False(childSpy.WasDisposed); }
public void MefDisposesMefComponentTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Register catalog and types unityContainer.RegisterCatalog(assemblyCatalog); unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent1>(); // Test var container = unityContainer.Resolve <CompositionContainer>(); var mefComponentDisposable = container.GetExportedValue <MefComponentDisposable>(); Assert.That(mefComponentDisposable, Is.Not.Null); Assert.That(mefComponentDisposable.GetType(), Is.EqualTo(typeof(MefComponentDisposable))); unityContainer.Dispose(); Assert.IsTrue(mefComponentDisposable.Disposed); }
public void CanDisposeChildWithoutDisposingParent() { MyDisposableObject parentSpy = new MyDisposableObject(); MyDisposableObject childSpy = new MyDisposableObject(); UnityContainer parent = new UnityContainer(); parent.RegisterInstance(parentSpy); IUnityContainer child = parent.CreateChildContainer() .RegisterInstance(childSpy); child.Dispose(); Assert.IsFalse(parentSpy.WasDisposed); Assert.IsTrue(childSpy.WasDisposed); childSpy.WasDisposed = false; parent.Dispose(); Assert.IsTrue(parentSpy.WasDisposed); Assert.IsFalse(childSpy.WasDisposed); }
public void DisposingParentDisposesChild() { UnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); DisposableObject spy = new DisposableObject(); child.RegisterInstance<DisposableObject>(spy); parent.Dispose(); Assert.True(spy.WasDisposed); }