public void UnityCanAccessMixedMefAndUnityComponents()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
unityContainer.RegisterType<IUnityService1, UnityService1>(
new ContainerControlledLifetimeManager(), true);
// Most complex test: UnityComponent2 has dependencies on both Unity
// and MEF components while specified MEF component has further
// dependencies on both Unity and MEF components
var unityComponent2 = unityContainer.Resolve<UnityComponent2>();
Assert.IsNotNull(unityComponent2);
var mefComponent3 = unityContainer.Resolve<IMefComponent1>("MefComponent3");
Assert.IsNotNull(mefComponent3);
Assert.IsTrue(mefComponent3 is MefComponent3);
var unityService1 = unityContainer.Resolve<IUnityService1>();
Assert.IsNotNull(unityService1);
Assert.AreSame(mefComponent3, unityComponent2.MefComponent1);
Assert.AreSame(unityService1, unityComponent2.UnityService1);
Assert.IsTrue(unityComponent2.MefComponent1 is MefComponent3);
var originalMefComponent3 = (MefComponent3)unityComponent2.MefComponent1;
Assert.IsNotNull(originalMefComponent3.MefComponent1);
Assert.IsNotNull(originalMefComponent3.UnityService1);
}
public void Unity_registered_components_take_precedence_over_MEF_registered_components_if_querying_for_a_single_component_registered_in_both_containers()
{
// Setup
var unityContainer = new UnityContainer();
var typeCatalog = new TypeCatalog(typeof (Singleton));
// Register catalog and types
unityContainer.RegisterCatalog(typeCatalog);
unityContainer.RegisterType<ISingleton, Singleton>(new ContainerControlledLifetimeManager());
// Reset count
Singleton.Count = 0;
Assert.That(Singleton.Count, Is.EqualTo(0));
var singleton = unityContainer.Resolve<ISingleton>();
Assert.That(singleton, Is.Not.Null);
Assert.That(Singleton.Count, Is.EqualTo(1));
var mef = unityContainer.Resolve<CompositionContainer>();
var mefSingleton = mef.GetExportedValue<ISingleton>();
Assert.That(Singleton.Count, Is.EqualTo(1));
Assert.That(singleton, Is.SameAs(mefSingleton));
}
private static UnityContainer ConfigureMefThenUnity()
{
var container = new UnityContainer();
var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
container.RegisterCatalog(catalog);
container.RegisterType<IUnityComponent, UnityComponent>();
container.RegisterType<ICountableUnityComponent, CountableUnityComponent>();
return container;
}
private static UnityContainer ConfigureUnityThenMef()
{
var container = new UnityContainer();
TypeRegistrationTrackerExtension.RegisterIfMissing(container);
var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
container.RegisterType<IUnityComponent, UnityComponent>();
container.RegisterType<ICountableUnityComponent, CountableUnityComponent>();
container.RegisterCatalog(catalog);
return container;
}
protected override void ConfigureContainer()
{
InitialiseMappings();
var unityContainer = new UnityContainer();
unityContainer.RegisterCatalog(AggregateCatalog);
ServiceConfiguration.Initialise(unityContainer);
Container = unityContainer.Resolve<CompositionContainer>();
base.ConfigureContainer();
}
public void UnityCanAccessCompositionContainer()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
var mefComponent1 = compositionContainer.GetExportedObject<IMefComponent1>();
Assert.IsNotNull(mefComponent1);
}
/// <summary>
/// Main entry point to the application.
/// </summary>
/// <param name="args">Command line arguments.</param>
private static void Main(string[] args)
{
#region Initialization
// Create the Unity container and self-register
var unity = new UnityContainer();
unity.RegisterInstance<IUnityContainer>(unity);
// Register MEF catalogs in Unity
unity.RegisterCatalog(new AssemblyCatalog(Assembly.GetEntryAssembly()));
unity.RegisterCatalog(new DirectoryCatalog("."));
#endregion
// Register unity components
unity.RegisterType<CoreComponent>();
unity.RegisterType<ICoreService, CoreService1>(new ContainerControlledLifetimeManager(), true);
unity.RegisterType<ICoreService, CoreService2>("CoreService2", new ContainerControlledLifetimeManager(), true);
// Run the "Application"
var p = unity.Resolve<Program>();
p.Run();
}
public void UnityCircularDependencyIsDetectedTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
unityContainer.RegisterType<UnityOnlyComponent1>();
// Test
var unityOnlyComponent1 = unityContainer.Resolve<UnityOnlyComponent1>();
Assert.That(unityOnlyComponent1, Is.Not.Null);
}
public void UnityCanResolveMefComponentThatHasUnityDependenciesTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
// Test
var mefComponent = unityContainer.Resolve<IMefComponentWithUnityDependencies>();
Assert.That(mefComponent, Is.Not.Null);
Assert.That(mefComponent.MefOnlyComponent.GetType(), Is.EqualTo(typeof(MefComponent1)));
Assert.That(mefComponent.UnityOnlyComponent.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
}
public void UnityCanAccessPureMefComponents()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var mefComponent1 = unityContainer.Resolve<IMefComponent1>();
Assert.IsNotNull(mefComponent1);
Assert.IsTrue(mefComponent1 is MefComponent1);
var unityComponent1 = unityContainer.Resolve<UnityComponent1>();
Assert.IsNotNull(unityComponent1);
Assert.AreSame(mefComponent1, unityComponent1.MefComponent1);
}
public void MefCanResolveMefComponentThatHasUnityAndMefDependenciesTest()
{
// 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 mefMixedComponent = container.GetExportedValue<MefMixedComponent>();
Assert.That(mefMixedComponent, Is.Not.Null);
Assert.That(mefMixedComponent.GetType(), Is.EqualTo(typeof(MefMixedComponent)));
Assert.That(mefMixedComponent.MefComponent.GetType(), Is.EqualTo(typeof(MefComponent1)));
Assert.That(mefMixedComponent.UnityComponent.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
}
public void MefCanAccessUnityContainer()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
var unityContainerFromMef1 = compositionContainer.GetExportedObject<IUnityContainer>();
Assert.IsNotNull(unityContainerFromMef1);
var unityContainerFromMef2 = compositionContainer.GetExportedObject<IUnityContainer>();
Assert.IsNotNull(unityContainerFromMef2);
Assert.AreSame(unityContainerFromMef1, unityContainerFromMef2);
Assert.AreSame(unityContainer, unityContainerFromMef2);
}
public void When_querying_MEF_for_a_multiple_components_registered_in_both_containers_all_instances_are_returned()
{
// Setup
var unityContainer = new UnityContainer();
var typeCatalog = new TypeCatalog(typeof(Singleton));
// Register catalog and types
unityContainer.RegisterCatalog(typeCatalog);
unityContainer.RegisterType<ISingleton, Singleton>(new ContainerControlledLifetimeManager());
// Reset count
Singleton.Count = 0;
Assert.That(Singleton.Count, Is.EqualTo(0));
var mef = unityContainer.Resolve<CompositionContainer>();
mef.GetExportedValues<ISingleton>();
Assert.That(Singleton.Count, Is.EqualTo(2));
}
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 MefCanAccessPureUnityComponents()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// This service will be visible to MEF
unityContainer.RegisterType<IUnityService1, UnityService1>(
new ContainerControlledLifetimeManager(), true);
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
var unityService1 = compositionContainer.GetExportedObject<IUnityService1>();
var unityService2 = compositionContainer.GetExportedObject<IUnityService1>();
Assert.IsNotNull(unityService1);
Assert.IsNotNull(unityService2);
Assert.AreSame(unityService1, unityService2);
}
public void MefResolvesServiceRegisteredInUnityByTypeTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
// Registration
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>(new ContainerControlledLifetimeManager());
var container = unityContainer.Resolve<CompositionContainer>();
var unityOnlyComponent = container.GetExportedValue<IUnityOnlyComponent>();
var unityOnlyComponent2 = unityContainer.Resolve<IUnityOnlyComponent>();
Assert.That(unityOnlyComponent, Is.Not.Null);
Assert.That(unityOnlyComponent.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
Assert.That(unityOnlyComponent2, Is.Not.Null);
Assert.That(unityOnlyComponent2.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
Assert.That(unityOnlyComponent, Is.EqualTo(unityOnlyComponent2));
}
public void MefCanAccessMixedUnityAndMefComponents()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// This service will be visible to MEF
unityContainer.RegisterType<IUnityService1, UnityService1>(
new ContainerControlledLifetimeManager(), true);
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
var mefComponent3 = compositionContainer.GetExportedObject<IMefComponent1>("MefComponent3");
Assert.IsTrue(mefComponent3 is MefComponent3);
Assert.IsNotNull(mefComponent3);
var originalMefComponent3 = (MefComponent3) mefComponent3;
Assert.IsNotNull(originalMefComponent3.MefComponent1);
Assert.IsNotNull(originalMefComponent3.UnityService1);
}
public void UnityDoesNotSupportMefComponentsCollections()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var mefComponents = unityContainer.ResolveAll<IMefComponent1>();
Assert.IsNotNull(mefComponents);
Assert.IsTrue(mefComponents.Count() == 0);
}
public void UnityComponentsHaveMefDependenciesInjected()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var unityComponent0 = unityContainer.Resolve<UnityComponent0>();
Assert.IsNotNull(unityComponent0);
Assert.IsNotNull(unityComponent0.MefComponent1);
var mefComponent1 = unityContainer.Resolve<IMefComponent1>();
Assert.IsNotNull(mefComponent1);
Assert.IsTrue(mefComponent1 is MefComponent1);
Assert.AreSame(mefComponent1, unityComponent0.MefComponent1);
}
public void MefCanNotAccessPureUnityComponentsIfNotProperlyRegistered()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// This service will not be visible to MEF
unityContainer.RegisterType<IUnityService1, UnityService1>(
new ContainerControlledLifetimeManager());
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
// Exception here
Assert.That(delegate
{
compositionContainer.GetExportedObject<IUnityService1>();
}, Throws.TypeOf<ImportCardinalityMismatchException>());
}
public void UnityResolvesUnityComponentRegisteredWithoutInterfaceTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
// Registration
unityContainer.RegisterType<UnityComponent3>();
var component2 = unityContainer.Resolve<UnityComponent2>();
Assert.That(component2, Is.Not.Null);
Assert.That(component2.ImportedMefComponent, Is.Not.Null);
Assert.That(component2.ImportedMefComponent.GetType(), Is.EqualTo(typeof(MefComponent2)));
Assert.That(component2.MefComponent.GetType(), Is.EqualTo(typeof(MefComponent2)));
}
public void UnityCanResolveEnumerableOfTypesRegisteredInUnityAndMefEvenIfBothMefAndUnityRegisterTheSameTypeTest()
{
// Setup
var unityContainer = new UnityContainer();
unityContainer.RegisterCatalog(new AssemblyCatalog(typeof(IModule).Assembly));
unityContainer.RegisterType<IModule, Module1>();
unityContainer.RegisterType<IModule, Module2>("module2");
var modules1 = unityContainer.Resolve<IEnumerable<IModule>>();
Assert.That(modules1.Count(), Is.EqualTo(3));
Assert.That(modules1.OfType<Module1>().Count(), Is.EqualTo(2));
var modules2 = unityContainer.Resolve<IEnumerable<IModule>>();
Assert.That(modules2.Count(), Is.EqualTo(3));
Assert.That(modules1.OfType<Module1>().Count(), Is.EqualTo(2));
}
public void UnityCannotAccessMultipleMefComponents()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
Assert.That(delegate
{
unityContainer.Resolve<IMefComponent2>();
}, Throws.TypeOf<ResolutionFailedException>());
}
public void UnityCanResolveMefComponentRegisteredUsingAddExportedValueTest()
{
MefSingletonComponent.Counter = 0;
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
var compositionContainer = unityContainer.Configure<CompositionIntegration>().CompositionContainer;
var batch = new CompositionBatch();
var singletonComponent = new MefSingletonComponent();
batch.AddExportedValue(singletonComponent);
compositionContainer.Compose(batch);
var singletonComponent1 = compositionContainer.GetExport<MefSingletonComponent>().Value;
Assert.That(MefSingletonComponent.Counter, Is.EqualTo(1));
Assert.That(singletonComponent1, Is.SameAs(singletonComponent));
var singletonComponent2 = unityContainer.Resolve<MefSingletonComponent>();
Assert.That(MefSingletonComponent.Counter, Is.EqualTo(1));
Assert.That(singletonComponent2, Is.SameAs(singletonComponent));
}
public void UnityComponentsDontHaveMefDependenciesInjectedIfMarkedWithPartNotComposableAttribute()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var unityComponent00 = unityContainer.Resolve<UnityComponent00>();
Assert.IsNotNull(unityComponent00);
Assert.IsNull(unityComponent00.MefComponent1);
}
public void UnityContainerCanBeResolvedByMefTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Register catalog and types
unityContainer.RegisterCatalog(assemblyCatalog);
var compositionContainer1 = unityContainer.Resolve<CompositionContainer>();
var compositionContainer2 = unityContainer.Resolve<CompositionContainer>();
Assert.That(compositionContainer1, Is.Not.Null);
Assert.That(compositionContainer2, Is.Not.Null);
Assert.That(compositionContainer1, Is.SameAs(compositionContainer2));
var unityContainerFromMef1 = compositionContainer1.GetExportedValue<IUnityContainer>();
var unityContainerFromMef2 = compositionContainer1.GetExportedValue<IUnityContainer>();
Assert.That(unityContainerFromMef1, Is.Not.Null);
Assert.That(unityContainerFromMef2, Is.Not.Null);
Assert.AreSame(unityContainerFromMef1, unityContainerFromMef2);
Assert.AreSame(unityContainer, unityContainerFromMef1);
}
public void MefComponentsDontHaveUnityDependenciesInjectedUsingInjectionMethod()
{
var unityContainer = new UnityContainer();
// Register MEF catalog in Unity
unityContainer.RegisterCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
unityContainer.RegisterType<IUnityService1, UnityService1>(true);
unityContainer.RegisterType<IUnityService1, UnityService2>("UnityService2", true);
var compositionContainer = unityContainer.Resolve<CompositionContainer>();
Assert.IsNotNull(compositionContainer);
var mefComponent3 = compositionContainer.GetExportedObject<IMefComponent1>("MefComponent3");
Assert.IsTrue(mefComponent3 is MefComponent3);
Assert.IsNotNull(mefComponent3);
var originalMefComponent3 = (MefComponent3)mefComponent3;
Assert.IsNotNull(originalMefComponent3.MefComponent1);
Assert.IsNotNull(originalMefComponent3.UnityService1);
// Limited functionality
Assert.IsNull(originalMefComponent3.UnityService1_1);
}