protected override void Initialize() { TypeRegistrationTrackerExtension.RegisterIfMissing(Container); m_CompositionContainer = PrepareCompositionContainer(); Debug.Assert(Container == Context.Container); Debug.Assert(Container.IsTypeRegistered(typeof(CompositionContainer)) == Container.IsRegistered <CompositionContainer>()); Debug.Assert(Container.IsTypeRegistered(typeof(CompositionContainer)) == UnityContainerHelper.IsTypeRegistered(Container, typeof(CompositionContainer))); //#if true || NET40 // if (!Container.IsTypeRegistered(typeof(CompositionContainer))) // { // Context.Container.RegisterInstance(typeof(CompositionContainer), m_CompositionContainer); // } // //IServiceLocator locator = ServiceLocator.Current; //#else // Context.Locator.Add(typeof(CompositionContainer), m_CompositionContainer); //#endif Context.Policies.SetDefault <ICompositionContainerPolicy>(new CompositionContainerPolicy(m_CompositionContainer)); Context.Strategies.AddNew <CompositionStrategy>(UnityBuildStage.TypeMapping); Context.Strategies.AddNew <ComposeStrategy>(UnityBuildStage.Initialization); }
protected override void Initialize() { TypeRegistrationTrackerExtension.RegisterIfMissing(Container); m_CompositionContainer = PrepareCompositionContainer(); Context.Policies.SetDefault <ICompositionContainerPolicy>(new CompositionContainerPolicy(m_CompositionContainer)); Context.Strategies.AddNew <CompositionStrategy>(UnityBuildStage.TypeMapping); Context.Strategies.AddNew <ComposeStrategy>(UnityBuildStage.Initialization); }
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); }
private void ConfigureUnityContainer() { TypeRegistrationTrackerExtension.RegisterIfMissing(m_UnityContainer); var tracker = m_UnityContainer.Configure <TypeRegistrationTrackerExtension>(); foreach (var entry in tracker.Entries) { AddExportDefinition(entry.Type, entry.Name); } tracker.Registering += (s, e) => AddExportDefinition(e.TypeFrom ?? e.TypeTo, e.Name); tracker.RegisteringInstance += (s, e) => AddExportDefinition(e.RegisteredType, e.Name); }
/// <summary> /// Method called by <see cref="ContainerExportProvider"/> in order /// to initialize the adapter. /// </summary> public override void Initialize() { TypeRegistrationTrackerExtension.RegisterIfMissing(container); var tracker = this.container.Configure <TypeRegistrationTrackerExtension>(); foreach (var entry in tracker.Entries) { OnRegisteringComponent(entry.Type, entry.Name); } tracker.Registering += (s, e) => OnRegisteringComponent(e.TypeFrom ?? e.TypeTo, e.Name); tracker.RegisteringInstance += (s, e) => OnRegisteringComponent(e.RegisteredType, e.Name); }
/// <summary> /// Initial the container with this extension's functionality. /// </summary> /// <remarks> /// When overridden in a derived class, this method will modify the given /// <see cref="ExtensionContext"/> by adding strategies, policies, etc. /// to install it's functions into the container. /// </remarks> protected override void Initialize() { TypeRegistrationTrackerExtension.RegisterIfMissing(Container); this.compositionContainer = PrepareCompositionContainer(); // Main strategies Context.Strategies.AddNew <EnumerableResolutionStrategy>(UnityBuildStage.TypeMapping); Context.Strategies.AddNew <CompositionStrategy>(UnityBuildStage.TypeMapping); Context.Strategies.AddNew <ComposeStrategy>(UnityBuildStage.Initialization); // Policies Context.Policies.Set <IBuildPlanPolicy>( new LazyResolveBuildPlanPolicy(), typeof(Lazy <>)); Context.Policies.SetDefault <ICompositionContainerPolicy>( new CompositionContainerPolicy(compositionContainer)); }
public void MefCanResolveTypesRegisteredInUnityAfterTrackingExtensionIsAddedTest() { // Setup var unityContainer = new UnityContainer(); // Enable tracking TypeRegistrationTrackerExtension.RegisterIfMissing(unityContainer); // Registration unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2"); // Further setup var adapter = new UnityContainerAdapter(unityContainer); var provider = new ContainerExportProvider(adapter); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); var container = new CompositionContainer(assemblyCatalog, provider); var component = container.GetExportedValue <IUnityOnlyComponent>("unityComponent2"); Assert.That(component, Is.Not.Null); Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent2))); }
/// <summary> /// Returns whether a specified type has a type mapping registered in the container. /// </summary> /// <param name="container">The <see cref="IUnityContainer"/> to check for the type mapping.</param> /// <param name="type">The type to check if there is a type mapping for.</param> /// <returns><see langword="true"/> if there is a type mapping registered for <paramref name="type"/>.</returns> /// <remarks>In order to use this extension method, you first need to add the /// <see cref="IUnityContainer"/> extension to the <see cref="TypeRegistrationTrackerExtension"/>. /// </remarks> public static bool IsTypeRegistered(this IUnityContainer container, Type type) { return(TypeRegistrationTrackerExtension.IsTypeRegistered(container, type)); }