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 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 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);
}
