public void MefCanResolveLazyTypesRegisteredInAutofacTest()
        {
            // Setup
            var builder = new ContainerBuilder();

            builder.RegisterType <AutofacOnlyComponent1>().As <IAutofacOnlyComponent>();
            builder.RegisterType <AutofacOnlyComponent2>().Named <IAutofacOnlyComponent>("a");
            var autofacContainer = builder.Build();
            var adapter          = new AutofacContainerAdapter(autofacContainer);
            var provider         = new ContainerExportProvider(adapter);
            var assemblyCatalog  = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var container        = new CompositionContainer(assemblyCatalog, provider);

            AutofacOnlyComponent1.InstanceCount = 0;

            var lazyAutofacComponent = container.GetExports <IAutofacOnlyComponent>().ToList();

            Assert.That(lazyAutofacComponent, Is.Not.Null);
            Assert.That(AutofacOnlyComponent1.InstanceCount, Is.EqualTo(0));

            Assert.That(lazyAutofacComponent, Is.Not.Null);
            Assert.That(lazyAutofacComponent[0].Value, Is.Not.Null);
            Assert.That(lazyAutofacComponent[1].Value, Is.Not.Null);
            Assert.That(AutofacOnlyComponent1.InstanceCount, Is.EqualTo(1));
        }
        /// <summary>
        /// Enables Managed Extensibility Framework two-way integration.
        /// </summary>
        /// <param name="unityContainer">Target container.</param>
        /// <returns>
        /// <see cref="CompositionIntegration"/> instance.
        /// </returns>
        public static CompositionIntegration EnableCompositionIntegration(
            this IUnityContainer unityContainer)
        {
            lock (unityContainer)
            {
                var extension = unityContainer.Configure<CompositionIntegration>();
                if (extension == null)
                {
                    var adapter = new UnityContainerAdapter(unityContainer);
                    var containerExportProvider = new ContainerExportProvider(adapter);
                    var parentExtension = (CompositionIntegration) null;

                    if (unityContainer.Parent != null)
                    {
                        parentExtension = unityContainer.Parent.Configure<CompositionIntegration>();
                    }

                    if (parentExtension != null)
                    {
                        // Get the parent ContainerExportProvider
                        var parentContainerExportProvider = (ContainerExportProvider)parentExtension.Providers.Where(
                            ep => typeof(ContainerExportProvider).IsAssignableFrom(ep.GetType())).First();

                        // Collect all the exports provided by the parent container and add
                        // them to the child export provider
                        foreach (var definition in parentContainerExportProvider.RegistrationBasedFactoryExportProvider.ReadOnlyDefinitions)
                        {
                            containerExportProvider.RegistrationBasedFactoryExportProvider.Register(
                                definition.ContractType,
                                definition.RegistrationName);
                        }

                        // Grab all the parent export providers except the container ones
                        var parentExporters = new List<ExportProvider>(
                            parentExtension.Providers.Where(
                                ep => !typeof (ContainerExportProvider).IsAssignableFrom(ep.GetType())))
                                                  { containerExportProvider };

                        var catalog = new AggregateCatalog(parentExtension.Catalogs);

                        extension = new CompositionIntegration(true, parentExporters.ToArray());
                        extension.Catalogs.Add(catalog);
                    }
                    else
                    {
                        extension = new CompositionIntegration(true, containerExportProvider);
                    }

                    unityContainer.AddExtension(extension);
                }

                return extension;
            }
        }
        public void ExportProviderResolvesServiceRegisteredByTypeTest()
        {
            // Setup
            var unityContainer = new UnityContainer();
            var adapter = new UnityContainerAdapter(unityContainer);
            var provider = new ContainerExportProvider(adapter);

            // Registration
            unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();

            var component = provider.GetExportedValue<IUnityOnlyComponent>();
            Assert.That(component, Is.Not.Null);
            Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
        }
        public void ExportProviderResolvesServiceRegisteredByTypeTest()
        {
            // Setup
            var builder = new ContainerBuilder();

            builder.RegisterType <AutofacOnlyComponent1>().As <IAutofacOnlyComponent>();
            var autofacContainer = builder.Build();
            var adapter          = new AutofacContainerAdapter(autofacContainer);
            var provider         = new ContainerExportProvider(adapter);

            var component = provider.GetExportedValue <IAutofacOnlyComponent>();

            Assert.That(component, Is.Not.Null);
            Assert.That(component.GetType(), Is.EqualTo(typeof(AutofacOnlyComponent1)));
        }
        public void ExportProviderResolvesServicesRegisteredByTypeTest()
        {
            // Setup
            var unityContainer = new UnityContainer();
            var adapter = new UnityContainerAdapter(unityContainer);
            var provider = new ContainerExportProvider(adapter);

            // Registration
            unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
            unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent2>("b");

            var components = provider.GetExports<IUnityOnlyComponent>();
            Assert.That(components, Is.Not.Null);
            Assert.That(components.Count(), Is.EqualTo(2));

            Assert.That(components.Select(t => t.Value).OfType<UnityOnlyComponent1>().Count(), Is.EqualTo(1));
            Assert.That(components.Select(t => t.Value).OfType<UnityOnlyComponent2>().Count(), Is.EqualTo(1));
        }
        public void ExportProviderResolvesServicesRegisteredByTypeTest()
        {
            // Setup
            var builder = new ContainerBuilder();

            builder.RegisterType <AutofacOnlyComponent1>().As <IAutofacOnlyComponent>();
            builder.RegisterType <AutofacOnlyComponent2>().Named <IAutofacOnlyComponent>("b");
            var autofacContainer = builder.Build();
            var adapter          = new AutofacContainerAdapter(autofacContainer);
            var provider         = new ContainerExportProvider(adapter);

            var components = provider.GetExports <IAutofacOnlyComponent>();

            Assert.That(components, Is.Not.Null);
            Assert.That(components.Count(), Is.EqualTo(2));

            Assert.That(components.Select(t => t.Value).OfType <AutofacOnlyComponent1>().Count(), Is.EqualTo(1));
            Assert.That(components.Select(t => t.Value).OfType <AutofacOnlyComponent2>().Count(), Is.EqualTo(1));
        }
        public void MefCanResolveTypesRegisteredInAutofacAfterTrackingExtensionIsAddedTest()
        {
            // Setup
            var builder = new ContainerBuilder();

            builder.RegisterType <AutofacOnlyComponent2>().Named <IAutofacOnlyComponent>("autofacComponent2");
            var autofacContainer = builder.Build();

            // Further setup
            var adapter         = new AutofacContainerAdapter(autofacContainer);
            var provider        = new ContainerExportProvider(adapter);
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var container       = new CompositionContainer(assemblyCatalog, provider);

            var component = container.GetExportedValue <IAutofacOnlyComponent>("autofacComponent2");

            Assert.That(component, Is.Not.Null);
            Assert.That(component.GetType(), Is.EqualTo(typeof(AutofacOnlyComponent2)));
        }
        public void ComposeWithTwoContainerExportProvidersTest()
        {
            var unityContainer1 = new UnityContainer();
            var exportProvider1 = new ContainerExportProvider(new UnityContainerAdapter(unityContainer1));

            var a = new A();
            unityContainer1.RegisterInstance<A>(a);

            var unityContainer2 = new UnityContainer();
            var exportProvider2 = new ContainerExportProvider(new UnityContainerAdapter(unityContainer2));

            var b = new B();
            unityContainer2.RegisterInstance<B>(b);

            var catalog = new TypeCatalog(typeof(C));
            var compositionContainer = new CompositionContainer(catalog, exportProvider1, exportProvider2);
            var instance = compositionContainer.GetExport<C>();
            Assert.IsNotNull(instance.Value);
            Assert.AreEqual(a, instance.Value.ThingA, "Instance of A is the same as that registered with the DI container.");
            Assert.AreEqual(b, instance.Value.ThingB, "Instance of B is the same as that registered with the DI container.");
        }
        public void MefCannotResolveTypesRegisteredInUnityBeforeTrackingExtensionIsAddedTest()
        {
            // Setup
            var unityContainer = new 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);

            Assert.That(delegate
            {
                container.GetExportedValue<IUnityOnlyComponent>("unityComponent2");
            }, Throws.TypeOf<ImportCardinalityMismatchException>());
        }
        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)));
        }
        public void MefCanResolveLazyTypesRegisteredInUnityTest()
        {
            // Setup
            var unityContainer = new UnityContainer();
            var adapter = new UnityContainerAdapter(unityContainer);
            var provider = new ContainerExportProvider(adapter);
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var container = new CompositionContainer(assemblyCatalog, provider);

            UnityOnlyComponent1.InstanceCount = 0;
            unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
            unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent2>("a");

            var lazyUnityComponent = container.GetExports<IUnityOnlyComponent>().ToList();
            Assert.That(lazyUnityComponent, Is.Not.Null);
            Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(0));

            Assert.That(lazyUnityComponent, Is.Not.Null);
            Assert.That(lazyUnityComponent[0].Value, Is.Not.Null);
            Assert.That(lazyUnityComponent[1].Value, Is.Not.Null);
            Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(1));
        }
Пример #12
0
        private void ConfigureMef()
        {
            var adapter = new AutofacContainerAdapter(_context);
            var containerExportProvider = new ContainerExportProvider(adapter);
            var scope = _context as ISharingLifetimeScope;
            if (scope != null)
            {
                var parentScope = scope.ParentLifetimeScope;
                var parent = parentScope != null ? parentScope.ResolveOptional<CompositionIntegration>() : null;
                if (parent != null)
                {
                    // Get the parent ContainerExportProvider
                    var parentContainerExportProvider = (ContainerExportProvider) parent.Providers.Where(
                        ep => typeof (ContainerExportProvider).IsAssignableFrom(ep.GetType())).First();

                    // Collect all the exports provided by the parent container and add
                    // them to the child export provider
                    foreach (var definition in parentContainerExportProvider.FactoryExportProvider.ReadOnlyDefinitions)
                    {
                        containerExportProvider.FactoryExportProvider.Register(
                            definition.ContractType,
                            definition.RegistrationName);
                    }

                    // Grab all the parent export providers except the container ones
                    var exportProviders = new List<ExportProvider>(
                        parent.Providers.Where(
                            ep => !typeof (ContainerExportProvider).IsAssignableFrom(ep.GetType())))
                                              {containerExportProvider};

                    var catalog = new AggregateCatalog(parent.Catalogs);
                        //NOTE: this might result in duplicate exports... need to investigate.

                    Register = true;
                    _providers = exportProviders.ToArray();
                    Catalogs.Add(catalog);
                }
                else
                {
                    Register = true;
                    _providers = new ExportProvider[] {containerExportProvider};
                }
            }
        }