Exemple #1
0
        public void Factory_export_provider_can_resolve_additional_exports_from_the_factory()
        {
            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider        = new FactoryExportProvider();
            var container       = new CompositionContainer(assemblyCatalog, provider);

            provider.SourceProvider = provider;

            provider.RegisterInstance <IExternalComponent>(ep => new ExternalComponent2());
            provider.Register <IExternalComponent>("ext3", ep => new ExternalComponent3(ep.GetExportedValue <IExternalComponent>()));

            var externalComponent1 = container.GetExportedValue <IExternalComponent>("ext3");

            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent3)));
            var externalComponent13 = (ExternalComponent3)externalComponent1;

            Assert.That(externalComponent13.ExternalComponent, Is.Not.Null);
            Assert.That(externalComponent13.ExternalComponent.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            var externalComponent2 = container.GetExportedValue <IExternalComponent>("ext3");

            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent3)));
            var externalComponent23 = (ExternalComponent3)externalComponent1;

            Assert.That(externalComponent23.ExternalComponent, Is.Not.Null);
            Assert.That(externalComponent23.ExternalComponent.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            Assert.That(externalComponent13.ExternalComponent, Is.SameAs(externalComponent23.ExternalComponent));
        }
Exemple #2
0
        public void Factory_export_provider_can_resolve_single_instance_given_by_registration_name_registered_using_generic_overload()
        {
            var count = 0;

            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider        = new FactoryExportProvider();
            var container       = new CompositionContainer(assemblyCatalog, provider);

            provider.SourceProvider = container;

            provider.RegisterInstance <IExternalComponent>("ext2", ep =>
            {
                count++;
                return(new ExternalComponent2());
            });

            var externalComponent1 = container.GetExportedValue <IExternalComponent>("ext2");

            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            var externalComponent2 = container.GetExportedValue <IExternalComponent>("ext2");

            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            Assert.That(count, Is.EqualTo(1));
            Assert.That(externalComponent1, Is.EqualTo(externalComponent2));
        }
Exemple #3
0
        public void Factory_export_provider_can_resolve_single_instance()
        {
            var count = 0;

            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider        = new FactoryExportProvider();
            var container       = new CompositionContainer(assemblyCatalog, provider);

            provider.RegisterInstance(typeof(IExternalComponent), ep =>
            {
                count++;
                return(new ExternalComponent1());
            });

            var externalComponent1 = container.GetExportedValue <IExternalComponent>();

            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent1)));

            var externalComponent2 = container.GetExportedValue <IExternalComponent>();

            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent1)));

            Assert.That(count, Is.EqualTo(1));
            Assert.That(externalComponent1, Is.EqualTo(externalComponent2));
        }
Exemple #4
0
        public void Factory_export_provider_throws_exception_when_resolving_unknown_parts()
        {
            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider        = new FactoryExportProvider();
            var container       = new CompositionContainer(assemblyCatalog, provider);

            provider.SourceProvider = provider;

            provider.RegisterInstance <IExternalComponent>("ext", ep => new ExternalComponent2());


            Assert.That(delegate
            {
                container.GetExportedValue <IExternalComponent>();
            }, Throws.TypeOf <ImportCardinalityMismatchException>());

            var externalComponent2 = container.GetExportedValue <IExternalComponent>("ext");

            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent2)));
        }
        public void FactoryExportProviderResolvesSingleInstanceTest()
        {
            var count = 0;

            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider = new FactoryExportProvider();
            var container = new CompositionContainer(assemblyCatalog, provider);

            provider.RegisterInstance(typeof(IExternalComponent), ep =>
            {
                count++;
                return new ExternalComponent1();
            });

            var externalComponent1 = container.GetExportedValue<IExternalComponent>();
            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent1)));

            var externalComponent2 = container.GetExportedValue<IExternalComponent>();
            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent1)));

            Assert.That(count, Is.EqualTo(1));
            Assert.That(externalComponent1, Is.EqualTo(externalComponent2));
        }
        public void FactoryExportProviderResolvesAdditionalExportsFromTheFactoryTest()
        {
            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider = new FactoryExportProvider();
            var container = new CompositionContainer(assemblyCatalog, provider);
            provider.SourceProvider = provider;

            provider.RegisterInstance<IExternalComponent>(ep => new ExternalComponent2());
            provider.Register<IExternalComponent>("ext3", ep => new ExternalComponent3(ep.GetExportedValue<IExternalComponent>()));

            var externalComponent1 = container.GetExportedValue<IExternalComponent>("ext3");
            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent3)));
            var externalComponent13 = (ExternalComponent3) externalComponent1;
            Assert.That(externalComponent13.ExternalComponent, Is.Not.Null);
            Assert.That(externalComponent13.ExternalComponent.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            var externalComponent2 = container.GetExportedValue<IExternalComponent>("ext3");
            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent3)));
            var externalComponent23 = (ExternalComponent3)externalComponent1;
            Assert.That(externalComponent23.ExternalComponent, Is.Not.Null);
            Assert.That(externalComponent23.ExternalComponent.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            Assert.That(externalComponent13.ExternalComponent, Is.SameAs(externalComponent23.ExternalComponent));
        }
        public void FactoryExportProviderDoesNotResolveUnknownPartsTest()
        {
            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider = new FactoryExportProvider();
            var container = new CompositionContainer(assemblyCatalog, provider);
            provider.SourceProvider = provider;

            provider.RegisterInstance<IExternalComponent>("ext", ep => new ExternalComponent2());

            Assert.That(delegate
                        {
                            container.GetExportedValue<IExternalComponent>();
                        }, Throws.TypeOf<ImportCardinalityMismatchException>());

            var externalComponent2 = container.GetExportedValue<IExternalComponent>("ext");
            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent2)));
        }
        public void Factory_export_provider_can_resolve_single_instance_given_by_registration_name_registered_using_generic_overload()
        {
            var count = 0;

            // Setup
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var provider = new FactoryExportProvider();
            var container = new CompositionContainer(assemblyCatalog, provider);
            provider.SourceProvider = container;

            provider.RegisterInstance<IExternalComponent>("ext2", ep =>
            {
                count++;
                return new ExternalComponent2();
            });

            var externalComponent1 = container.GetExportedValue<IExternalComponent>("ext2");
            Assert.That(externalComponent1, Is.Not.Null);
            Assert.That(externalComponent1.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            var externalComponent2 = container.GetExportedValue<IExternalComponent>("ext2");
            Assert.That(externalComponent2, Is.Not.Null);
            Assert.That(externalComponent2.GetType(), Is.EqualTo(typeof(ExternalComponent2)));

            Assert.That(count, Is.EqualTo(1));
            Assert.That(externalComponent1, Is.EqualTo(externalComponent2));
        }