C# ContainerBuilder.RegisterComposablePartCatalog方法代码示例

 public void DefaultLifetimeForMefComponentsIsSingleton()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(HasDefaultCreationPolicy));
     builder.RegisterComposablePartCatalog(catalog);
     AssertDisposalTrackerIsSingleton(builder);
 }

 public void AnyCreationPolicyDefaultsToShared()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(HasAnyCreationPolicy));
     builder.RegisterComposablePartCatalog(catalog);
     AssertDisposalTrackerIsSingleton(builder);
 }

 public void MissingDependencyDetected()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(HasMissingDependency));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     Assert.Throws<ComponentNotRegisteredException>(() => container.Resolve<HasMissingDependency>());
 }

 private static IContainer RegisterTypeCatalogContaining(params Type[] types)
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(types);
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     return container;
 }

 public void ExcludesExportsWithoutRequiredMetadata()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(RequiresMetadataAllowsDefault), typeof(HasNoMetadata));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var rm = container.Resolve<RequiresMetadataAllowsDefault>();
     Assert.IsNull(rm.Dependency);
 }

 public void SatisfiesImportOnMefComponentFromMef()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(MefDependency), typeof(ImportsMefDependency));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var bar = container.Resolve<ImportsMefDependency>();
     Assert.IsNotNull(bar.Dependency);
 }

 public void RetrievesExportedInterfaceFromCatalogPart()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(MefDependency));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var foo = container.Resolve<IDependency>();
     Assert.IsAssignableFrom<MefDependency>(foo);
 }

 public void ResolvesExportsFromContext()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(MefDependency));
     builder.RegisterComposablePartCatalog(catalog);
     builder.RegisterType<MefDependency>().Exported(e => e.As<IDependency>());
     var container = builder.Build();
     var exports = container.ResolveExports<IDependency>();
     Assert.AreEqual(2, exports.Count());
 }

 public void ImportsEmptyCollectionIfDependencyMissing()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(ImportsMany));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var im = container.Resolve<ImportsMany>();
     Assert.IsNotNull(im.Dependencies);
     Assert.IsFalse(im.Dependencies.Any());
 }

 public void RespectsNonSharedCreationPolicy()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(typeof(HasNonSharedCreationPolicy));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var instance1 = container.Resolve<DisposalTracker>();
     var instance2 = container.Resolve<DisposalTracker>();
     Assert.IsAssignableFrom<HasNonSharedCreationPolicy>(instance1);
     Assert.AreNotSame(instance1, instance2);
     Assert.IsFalse(instance1.IsDisposedPublic);
     Assert.IsFalse(instance2.IsDisposedPublic);
     container.Dispose();
     Assert.IsTrue(instance1.IsDisposedPublic);
     Assert.IsTrue(instance2.IsDisposedPublic);
 }

        public void ClassRegisteredInAutofacAsFactoryScopedIsResolvedByMefAsFactoryScoped()
        {
            var containerBuilder = new ContainerBuilder();

            var newAssemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            containerBuilder.RegisterComposablePartCatalog(newAssemblyCatalog);
            containerBuilder.RegisterType<RegisteredInAutofac2>();
            containerBuilder.RegisterType<RegisteredInAutofacAndExported>()
                .Exported(e => e.As<RegisteredInAutofacAndExported>());

            var autofacContainer = containerBuilder.Build();

            var elementFromAutofac1 = autofacContainer.Resolve<RegisteredInAutofac2>();
            var elementFromAutofac2 = autofacContainer.Resolve<RegisteredInAutofac2>();

            Assert.AreNotSame(elementFromAutofac1, elementFromAutofac2);
            Assert.AreNotSame(elementFromAutofac1.ImportedFormMef, elementFromAutofac2.ImportedFormMef);
            Assert.AreNotSame(elementFromAutofac1.ImportedFormMef.ImportedFormAutofac, elementFromAutofac2.ImportedFormMef.ImportedFormAutofac);//fail
        }

        public void RespectsExplicitInterchangeServices()
        {
            var builder = new ContainerBuilder();
            var catalog = new TypeCatalog(typeof(HasMultipleExports));

            var interchangeService1 = new TypedService(typeof(HasMultipleExportsBase));
            var interchangeService2 = new KeyedService("b", typeof(HasMultipleExports));
            var nonInterchangeService1 = new TypedService(typeof(HasMultipleExports));
            var nonInterchangeService2 = new KeyedService("a", typeof(HasMultipleExports));

            builder.RegisterComposablePartCatalog(catalog,
                interchangeService1,
                interchangeService2);

            var container = builder.Build();

            Assert.IsTrue(container.IsRegisteredService(interchangeService1));
            Assert.IsTrue(container.IsRegisteredService(interchangeService2));
            Assert.IsFalse(container.IsRegisteredService(nonInterchangeService1));
            Assert.IsFalse(container.IsRegisteredService(nonInterchangeService2));
        }

 public void SetsMultipleExportsToZeroOrMoreCardinalityImports()
 {
     var builder = new ContainerBuilder();
     var catalog = new TypeCatalog(
         typeof(ImportsMany), typeof(HasMetadata), typeof(HasNoMetadata));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var rm = container.Resolve<ImportsMany>();
     Assert.IsNotNull(rm.Dependencies);
     Assert.AreEqual(2, rm.Dependencies.Count());
 }

 public void IncludesExportsWithRequiredMetadata()
 {
     var builder = new ContainerBuilder();
     builder.RegisterMetadataRegistrationSources();
     var catalog = new TypeCatalog(typeof(RequiresMetadata), typeof(HasMetadata));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var rm = container.Resolve<RequiresMetadata>();
     Assert.IsNotNull(rm.Dependency);
 }

 public void SupportsMetadataOnAutofacExports()
 {
     var builder = new ContainerBuilder();
     builder.RegisterMetadataRegistrationSources();
     var metadata = new Dictionary<string, object>
     {
         { "Key", "Value" }
     };
     const string exportedString = "Hello";
     builder.RegisterInstance(exportedString).Exported(e => e.As<string>().WithMetadata(metadata));
     var catalog = new TypeCatalog(typeof(RequiresMetadata));
     builder.RegisterComposablePartCatalog(catalog);
     var container = builder.Build();
     var rm = container.Resolve<RequiresMetadata>();
     Assert.IsNotNull(rm.Dependency);
     Assert.AreEqual(rm.Dependency.Value, "Hello");
 }