예제 #1
0
        static void Main(string[] args)
        {
            InterceptionConfiguration cfg = new InterceptionConfiguration()
                                            .AddInterceptor(new DynamicProxyInterceptor(new LoggingInterceptor()));

            //GenericTypeCatalog typeCatalog = new GenericTypeCatalog(typeof(GenericClass<int>), typeof(IGenericInterface<>));
            //AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            //AggregateCatalog aggregateCatalog = new AggregateCatalog(assemblyCatalog, typeCatalog);
            //GenericCatalog genericCatalog = new GenericCatalog(aggregateCatalog);
            //InterceptingCatalog interceptingCatalog = new InterceptingCatalog(genericCatalog, cfg);
            //CompositionContainer container = new CompositionContainer(interceptingCatalog);

//            GenericContractTypeMapping mapping = new GenericContractTypeMapping(typeof(IGenericInterface<>), typeof(GenericClass<>));

            TypeCatalog      typeCatalog      = new TypeCatalog(typeof(SampleClass), typeof(OrderProcessor), typeof(CtorOrderProcessor));
            AssemblyCatalog  assemblyCatalog  = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            GenericCatalog   genericCatalog   = new GenericCatalog(new TestGenericContractRegistry());
            AggregateCatalog aggregateCatalog = new AggregateCatalog(typeCatalog, genericCatalog);
            //CompositionContainer container = new CompositionContainer(aggregateCatalog);

            CompositionContainer container = new CompositionContainer(aggregateCatalog);
            var orderProcessor             = container.GetExportedValue <OrderProcessor>();
            var generic = container.GetExportedValue <IGenericInterface <string> >();

            CatalogExportProvider provider = new CatalogExportProvider(aggregateCatalog);

            provider.SourceProvider = provider;

            var instance = provider.GetExportedValue <ISampleInterface>();//container.GetExportedValue<ISampleInterface>();

            instance.Method1("test", 5);

            var genericInstance = provider.GetExportedValue <OrderProcessor>();//container.GetExportedValue<IGenericInterface<int>>();
            //var orderProcessor = provider.GetExportedValue<CtorOrderProcessor>();
        }
        public void Recomposition_PartDefWithNonRecomposableImportIsRemoved_ExportsMatchingImportChanged_ShouldNotBeRejected()
        {
            string dependencyContractName = "dependency";
            var    exportValue            = new object();

            var exporterPart = PartFactory.CreateExporter(dependencyContractName, exportValue);
            var importerPart = PartFactory.CreateImporter(dependencyContractName, false);

            var exporterCatalog = CatalogFactory.Create(exporterPart);
            var importerCatalog = CatalogFactory.Create(importerPart);

            var aggregateCatalog = CatalogFactory.CreateAggregateCatalog(importerCatalog, exporterCatalog);

            var provider = new CatalogExportProvider(aggregateCatalog);

            provider.SourceProvider = provider;

            var exports = provider.GetExports(importerPart.ImportDefinitions.Single());

            Assert.AreEqual(exportValue, importerPart.Value, "Importer was not composed");

            aggregateCatalog.Catalogs.Remove(importerCatalog);
            aggregateCatalog.Catalogs.Remove(exporterCatalog);

            Assert.AreEqual(exportValue, importerPart.Value, "Importer was unexpectedly recomposed");
        }
예제 #3
0
 public MefExportProvider(ComposablePartCatalog catalog)
 {
     _exportProvider = new CatalogExportProvider(catalog);
     //support recomposition
     _exportProvider.ExportsChanged  += (s, e) => OnExportsChanged(e);
     _exportProvider.ExportsChanging += (s, e) => OnExportsChanging(e);
 }
예제 #4
0
        /// <summary>
        /// Create the composition container used to locate and fixup imports.
        /// </summary>
        private void CreateContainer()
        {
            var defaultAssembly = Path.GetFileName(Assembly.GetExecutingAssembly().CodeBase);
            var localCatalog    = new CatalogExportProvider(new AssemblyCatalog(Assembly.GetExecutingAssembly()));

            // Get a catalog of all the assemblies *except* this one
            var catalog = new AggregateCatalog();

            foreach (string fname in
                     Directory.GetFiles(@".\", "*.exe")
                     .Concat(Directory.GetFiles(@".\", "*.dll"))
                     .Where(fname => string.Compare(Path.GetFileName(fname), defaultAssembly, true) != 0))
            {
                try
                {
                    if (Assembly.ReflectionOnlyLoadFrom(fname) != null)
                    {
                        catalog.Catalogs.Add(new AssemblyCatalog(fname));
                    }
                }
                catch
                {
                }
            }

            _container = new CompositionContainer(catalog, localCatalog);
            localCatalog.SourceProvider = _container;
        }
예제 #5
0
        private CompositionContainer PrepareCompositionContainer()
        {
            // Create the MEF container based on the catalog and given providers
            // Important: the catalog is wrapped with CatalogExportProvider which is
            // then added as a LAST catalog, this ensures that when querying Unity/MEF
            // for a single component, Unity components will always take precedence
            var catalogExportProvider = new CatalogExportProvider(this.aggregateCatalog, this.isThreadSafe);
            var providerList          = new List <ExportProvider>(this.providers);

            providerList.Add(catalogExportProvider);
            var container = new CompositionContainer(null, this.isThreadSafe, providerList.ToArray());

            catalogExportProvider.SourceProvider = container;

            // If desired, register an instance of CompositionContainer and Unity container in MEF,
            // this will also make CompositionContainer available to the Unity
            if (Register)
            {
                // Create composition batch and add the MEF container and the Unity
                // container to the MEF
                var batch = new CompositionBatch();
                batch.AddExportedValue(container);
                batch.AddExportedValue(Container);

                // Prepare container
                container.Compose(batch);
            }

            return(container);
        }
예제 #6
0
        /// <summary>
        /// By default, we are configured to use MEF
        /// </summary>
        protected override void Configure()
        {
            // Add all assemblies to AssemblySource (using a temporary DirectoryCatalog).
            var directoryCatalog = new DirectoryCatalog(@"./");

            AssemblySource.Instance.AddRange(
                directoryCatalog.Parts
                .Select(part => ReflectionModelServices.GetPartType(part).Value.Assembly)
                .Where(assembly => !AssemblySource.Instance.Contains(assembly)));

            // Prioritise the executable assembly. This allows the client project to override exports, including IShell.
            // The client project can override SelectAssemblies to choose which assemblies are prioritised.
            var priorityAssemblies = SelectAssemblies().ToList();
            var priorityCatalog    = new AggregateCatalog(priorityAssemblies.Select(x => new AssemblyCatalog(x)));
            var priorityProvider   = new CatalogExportProvider(priorityCatalog);

            // Now get all other assemblies (excluding the priority assemblies).
            var mainCatalog = new AggregateCatalog(
                AssemblySource.Instance
                .Where(assembly => !priorityAssemblies.Contains(assembly))
                .Select(x => new AssemblyCatalog(x)));
            var mainProvider = new CatalogExportProvider(mainCatalog);

            Container = new CompositionContainer(priorityProvider, mainProvider);
            priorityProvider.SourceProvider = Container;
            mainProvider.SourceProvider     = Container;

            var batch = new CompositionBatch();

            BindServices(batch);
            batch.AddExportedValue(mainCatalog);

            Container.Compose(batch);
        }
예제 #7
0
        public void Configure()
        {
            var priorityAssemblies = SelectAssemblies().ToList();
            var priorityCatalog    = new AggregateCatalog(priorityAssemblies.Select(x => new AssemblyCatalog(x)));
            var priorityProvider   = new CatalogExportProvider(priorityCatalog);

            var path = Path.GetDirectoryName(
                new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath);
            var search        = "uDicom.PACS.Service.dll";
            var codecCatalog  = new DirectoryCatalog(path, search);
            var codecProvider = new CatalogExportProvider(codecCatalog);

            Container = new CompositionContainer(priorityProvider, codecProvider);
            priorityProvider.SourceProvider = Container;
            codecProvider.SourceProvider    = Container;

            var batch = new CompositionBatch();

            batch.AddExportedValue(Container);

            Container.Compose(batch);

            IoC.GetInstance     = GetInstance;
            IoC.GetAllInstances = GetAllInstances;
        }
예제 #8
0
        /// <inheritdoc />
        /// <summary>
        /// Override to configure the framework and setup your IoC container.
        /// </summary>
        protected override void Configure()
        {
            // Add all assemblies to AssemblySource (using a temporary DirectoryCatalog).
            var directoryCatalog = new DirectoryCatalog(@".");

            AssemblySource.Instance.AddRange(
                directoryCatalog.Parts
                .Select(part => ReflectionModelServices.GetPartType(part).Value.Assembly)
                .Where(assembly => !AssemblySource.Instance.Contains(assembly)));

            _priorityAssemblies = SelectAssemblies().ToList();
            var priorityCatalog  = new AggregateCatalog(_priorityAssemblies.Select(x => new AssemblyCatalog(x)));
            var priorityProvider = new CatalogExportProvider(priorityCatalog);

            var mainCatalog = new AggregateCatalog(
                AssemblySource.Instance
                .Where(assembly => !_priorityAssemblies.Contains(assembly))
                .Select(x => new AssemblyCatalog(x)));
            var mainProvider = new CatalogExportProvider(mainCatalog);

            _container = new CompositionContainer(priorityProvider, mainProvider);
            priorityProvider.SourceProvider = _container;
            mainProvider.SourceProvider     = _container;

            var batch = new CompositionBatch();

            BindServices(batch);

            _container.Compose(batch);
        }
예제 #9
0
        public void TestInitialize()
        {
            var exp = new CatalogExportProvider(Catalog = CreateCatalog());
            var agg = new NancyExportProvider(exp);

            Container          = new CompositionContainer(agg);
            exp.SourceProvider = agg;
        }
        public void GetExports_NoSourceProvider_ShouldThrowInvalidOperation()
        {
            var catalog  = CatalogFactory.CreateAttributed();
            var provider = new CatalogExportProvider(catalog);

            ExceptionAssert.Throws <InvalidOperationException>(() =>
                                                               provider.GetExports(ImportFromContract("Foo")));
        }
예제 #11
0
        public AOPExportProvider(Func <ComposablePartCatalog> catalogResolver)
        {
            _exportProvider = new CatalogExportProvider(catalogResolver());

            //support recomposition
            _exportProvider.ExportsChanged  += (s, e) => OnExportsChanged(e);
            _exportProvider.ExportsChanging += (s, e) => OnExportsChanging(e);
        }
예제 #12
0
        /// <summary>Creates and returns a new <see cref="CompositionContainer"/> to be used by <see langword="this"/>.</summary>
        /// <returns>A new <see cref="CompositionContainer"/> to be used by <see langword="this"/>.</returns>
        public CompositionContainer CreateCompositionContainer()
        {
            var exportProvider       = new CatalogExportProvider(new AssemblyCatalog(GetType().Assembly));
            var compositionContainer = new CompositionContainer(CompositionOptions.IsThreadSafe, exportProvider);

            exportProvider.SourceProvider = compositionContainer;
            return(compositionContainer);
        }
예제 #13
0
        private void LoadRegistriesFromCatalog()
        {
            using (var ep = new CatalogExportProvider(this.decoratedCatalog))
            {
                ep.SourceProvider = ep;
                var registries = ep.GetExportedValues <IGenericContractRegistry>();

                LoadTypeMappings(registries);
            }
        }
예제 #14
0
        /// <summary>
        /// This uses MEF to perform a compose operation.
        /// </summary>
        /// <typeparam name="T">Type to look for</typeparam>
        /// <param name="contractName">MEF contract name</param>
        /// <param name="assemblyPath">Assembly path</param>
        /// <param name="filter">Filter for files</param>
        /// <returns></returns>
        private static List <T> Compose <T>(string contractName, string assemblyPath, string filter)
            where T : class
        {
            if (container == null)
            {
                ComposablePartCatalog partCatalog;

                var assembly = Assembly.GetEntryAssembly();
                if (assembly != null)
                {
                    partCatalog = new AggregateCatalog(
                        new AssemblyCatalog(assembly),
                        GetCatalogForDirectoryFileSpec(AssemblyResolver.BioInstallationPath, DLLFilter));
                }
                else
                {
                    partCatalog = GetCatalogForDirectoryFileSpec(AssemblyResolver.BioInstallationPath, DLLFilter);
                }

                // Add the add-in folder if we have one
                if (!string.IsNullOrEmpty(assemblyPath) && Directory.Exists(assemblyPath))
                {
                    var addinCatalog     = GetCatalogForDirectoryFileSpec(assemblyPath, filter);
                    var defaultCatalogEp = new CatalogExportProvider(partCatalog);
                    container = new CompositionContainer(addinCatalog, defaultCatalogEp);
                    defaultCatalogEp.SourceProvider = container;
                }
                else
                {
                    container = new CompositionContainer(partCatalog);
                }
            }

            List <T> availableTypes = new List <T>();
            var      exportList     = container.GetExports <T>(contractName);

            foreach (Lazy <T> foundType in exportList)
            {
                try
                {
                    T value = foundType.Value;
                    if (value != null)
                    {
                        availableTypes.Add(value);
                    }
                }
                catch (Exception ex)
                {
                    // Ignore if can't create.
                    Debug.WriteLine(ex.ToString());
                }
            }

            return(availableTypes);
        }
예제 #15
0
        public void Constructor_ValueAsCatalogArgument_ShouldSetCatalogPropertyToEmpty()
        {
            var expectations = Expectations.GetCatalogs();

            foreach (var e in expectations)
            {
                var provider = new CatalogExportProvider(e);

                Assert.Same(e, provider.Catalog);
            }
        }
예제 #16
0
        [ActiveIssue("https://github.com/dotnet/corefx/issues/25498", TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void ComponentCatalogResolverGetStaticExport()
        {
            var catalog = CatalogFactory.CreateDefaultAttributed();
            var catalogExportProvider = new CatalogExportProvider(catalog);

            catalogExportProvider.SourceProvider = catalogExportProvider;

            var exports = catalogExportProvider.GetExports(ImportFromContract("StaticString"));

            Assert.Equal(1, exports.Count());
            Assert.Equal("StaticString", exports.First().Value);
        }
        public void TestSetUp()
        {
            var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor), typeof(TestGenericContractRegistry));
            var cfg         = new InterceptionConfiguration().AddHandler(new GenericExportHandler());
            var catalog     = new InterceptingCatalog(typeCatalog, cfg);

            var provider = new CatalogExportProvider(catalog);

            provider.SourceProvider = provider;

            ExportProvider = provider;
        }
        public static CompositionContainer Create()
        {
            var productCatalog = new AggregateCatalog(
                new AssemblyCatalog(Assembly.Load("CodingArena.Game")),
                new AssemblyCatalog(Assembly.Load("CodingArena.Game.Console")));
            var exportProvider = new CatalogExportProvider(productCatalog);
            var testCatalog    = new AssemblyCatalog(Assembly.Load("CodingArena.Game.Tests"));
            var container      = new CompositionContainer(testCatalog, exportProvider);

            exportProvider.SourceProvider = container;
            return(container);
        }
예제 #19
0
        static NuPatternGlobalContainer()
        {
            var globalComponentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));

            if (globalComponentModel == null)
            {
                tracer.Warn(Resources.NuPatternGlobalContainer_TraceNoComponentModelService);
            }
            else
            {
                var catalog = globalComponentModel.GetCatalog(NuPattern.ComponentModel.Composition.Catalog.DefaultCatalogName);
                if (catalog == null)
                {
                    tracer.Warn(Resources.NuPatternGlobalContainer_TraceNoComponentModel, NuPattern.ComponentModel.Composition.Catalog.DefaultCatalogName);
                }
                else
                {
                    try
                    {
                        //
                        // Create our DecoratingReflectionCatalog
                        //
                        var componentsCatalog = new ComponentCatalog(catalog);

                        //
                        // Now create a catalog provider
                        //
                        CatalogExportProvider catalogProvider = new CatalogExportProvider(componentsCatalog);

                        //
                        // have it inherit the global provider
                        //
                        catalogProvider.SourceProvider = globalComponentModel.DefaultExportProvider;

                        //
                        // Create provider settings to look here first and then include others when not found
                        //
                        var providerSettings = new VsExportProviderSettings(
                            VsExportProvidingPreference.BeforeExportsFromOtherContainers,
                            VsExportSharingPolicy.IncludeExportsFromOthers);

                        //Instance = VsCompositionContainer.Create(componentsCatalog, providerSettings);
                        Instance = new CompositionContainer(componentsCatalog, globalComponentModel.DefaultExportProvider);
                    }
                    catch (Exception ex)
                    {
                        tracer.Error(ex, Resources.NuPatternGlobalContainer_TraceFailedContainerInitialization);
                        throw;
                    }
                }
            }
        }
        public static CompositionContainer Create()
        {
            var directoryCatalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);

            var exportProvider = new CatalogExportProvider(directoryCatalog);

            var testCatalog = new AssemblyCatalog(Assembly.Load("Beeffective.Tests"));

            var container = new CompositionContainer(testCatalog, exportProvider);

            exportProvider.SourceProvider = container;
            return(container);
        }
예제 #21
0
        [ActiveIssue("https://github.com/dotnet/corefx/issues/25498", TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void BasicTestWithRequiredMetadata_WrongTypeConstraint()
        {
            var catalog = CatalogFactory.CreateDefaultAttributed();
            var catalogExportProvider = new CatalogExportProvider(catalog);

            catalogExportProvider.SourceProvider = catalogExportProvider;

            Assert.Equal(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());

            Assert.Equal(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
            Assert.Equal(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo", "Bar" }, new Type[] { typeof(int), typeof(int) })).Count());

            Assert.Equal(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
            Assert.Equal(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
        }
예제 #22
0
        public void CreationPolicyShared_MultipleCallsReturnSameInstance()
        {
            var catalog  = CatalogFactory.CreateAttributed(typeof(CreationPolicyShared));
            var provider = new CatalogExportProvider(catalog);

            provider.SourceProvider = ContainerFactory.Create();

            var export = provider.GetExportedValue <CreationPolicyShared>();

            for (int i = 0; i < 5; i++) // 5 is arbitrarily chosen
            {
                var export1 = provider.GetExportedValue <CreationPolicyShared>();

                Assert.Equal(export, export1);
            }
        }
예제 #23
0
        [ActiveIssue("https://github.com/dotnet/corefx/issues/25498", TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void ComponentCatalogResolverComponentCatalogExportReference()
        {
            var catalog = CatalogFactory.CreateDefaultAttributed();
            var catalogExportProvider = new CatalogExportProvider(catalog);

            catalogExportProvider.SourceProvider = catalogExportProvider;

            var exports = catalogExportProvider.GetExports(ImportFromContract(AttributedModelServices.GetContractName(typeof(MyExporterWithValidMetadata))));

            Assert.Equal(1, exports.Count());

            var export = exports.First();

            Assert.Equal("world", export.Metadata["hello"]);

            Assert.IsType <MyExporterWithValidMetadata>(export.Value);
        }
예제 #24
0
        /// <summary>
        /// 从当前目录下的所有程序集中加载所有实现 <see cref="IExportTargeterControlFactory"/> 接口的实例
        /// </summary>
        public IList <IExportTargeterControlFactory> LoadIExportTargeterControlFactorys()
        {
            var providers = new List <IExportTargeterControlFactory>();

            String           directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            DirectoryCatalog catalog   = new DirectoryCatalog(directory, SearchPattern);

            using (CatalogExportProvider exportProvider = new CatalogExportProvider(catalog))
            {
                exportProvider.SourceProvider = exportProvider;
                var exports = exportProvider.GetExportedValues <IExportTargeterControlFactory>();
                providers.AddRange(exports);
            }

            this.ExportTargeterControlFactorys = providers;
            return(providers);
        }
예제 #25
0
        protected override void Configure()
        {
            var assemblies = SelectAssemblies();
            var catalog    = new AggregateCatalog(assemblies.Select(x => new AssemblyCatalog(x)));
            var provider   = new CatalogExportProvider(catalog);

            m_Container             = new CompositionContainer(provider);
            provider.SourceProvider = m_Container;

            var batch = new CompositionBatch();

            batch.AddExportedValue <IWindowManager>(new WindowManager());
            batch.AddExportedValue <IEventAggregator>(new EventAggregator());
            batch.AddExportedValue(m_Container);
            batch.AddExportedValue(catalog);

            m_Container.Compose(batch);
        }
예제 #26
0
        public IDynamicBindingContext CreateDynamicContext()
        {
            var bindingProvider = new CatalogExportProvider(this.bindingCatalog);
            var dynamicExports  = new CompositionContainer();
            var composition     = new CompositionContainer(
                dynamicExports,
                defaultCompositionProvider,
                bindingProvider,
                componentModel.DefaultExportProvider);

            bindingProvider.SourceProvider = composition;

            var context = new CompositionContainerDynamicBindingContext(dynamicExports, composition);

            context.AddExport <IDynamicBindingContext>(context);

            return(context);
        }
예제 #27
0
        protected override void Configure()
        {
            var priorityAssemblies = SelectAssemblies();

            var priorityCatalog = new AggregateCatalog(priorityAssemblies.Select(x => new AssemblyCatalog(x)));
            var catalog         = new CatalogExportProvider(priorityCatalog);

            _container             = new CompositionContainer(catalog);
            catalog.SourceProvider = _container;

            var batch = new CompositionBatch();

            BindServices(batch);
            batch.AddExportedValue(catalog);

            _container.Compose(batch);

            base.Configure();
        }
예제 #28
0
        public void TestSetUp()
        {
            var typeCatalog = new TypeCatalog(
                typeof(CtorOrderProcessor),
                typeof(OrderProcessor),
                typeof(ConcreteCtorOrderProcessor),
                typeof(ConcreteOrderProcessor),
                typeof(MyCtorOrderProcessor),
                typeof(MyOrderProcessor),
                typeof(MyOrderProcessorSetterOnly),
                typeof(MultiOrderProcessor));
            var genericCatalog   = new GenericCatalog(new TestGenericContractRegistry());
            var aggregateCatalog = new AggregateCatalog(typeCatalog, genericCatalog);
            var provider         = new CatalogExportProvider(aggregateCatalog);

            provider.SourceProvider = provider;

            ExportProvider = provider;
        }
예제 #29
0
        private void CreateBindingContainer()
        {
            // We leverage the Feature Runtime container, where all their components and extensions publish already.
            var defaultCatalog = this.componentModel.GetCatalog(NuPattern.VisualStudio.Composition.Catalog.DefaultCatalogName);
            var ourCatalog     = this.componentModel.GetCatalog(Catalog.DefaultCatalogName);

            if (defaultCatalog == null || ourCatalog == null)
            {
                throw new InvalidOperationException(Resources.BindingCompositionService_CatalogsNotAvailable);
            }

            try
            {
                // Transparently change the INuPatternCompositionService implementation for all components
                // without code changes by providing an instance earlier in the chain.
                // See http://codebetter.com/blogs/glenn.block/archive/2009/05/14/customizing-container-behavior-part-2-of-n-defaults.aspx
                this.defaultCompositionProvider = new CompositionContainer();
                defaultCompositionProvider.ComposeExportedValue <INuPatternCompositionService>(this);
                defaultCompositionProvider.ComposeExportedValue <SVsServiceProvider>((SVsServiceProvider)serviceProvider);

                // Decorated catalog of parts.
                // NOTE: caching the catalog also caches the instantiated shared parts, if any.
                this.bindingCatalog = new BindingComponentCatalog(new AggregateCatalog(ourCatalog, defaultCatalog));
                var bindingProvider = new CatalogExportProvider(this.bindingCatalog);

                this.container = new CompositionContainer(
                    defaultCompositionProvider,
                    bindingProvider,
                    componentModel.DefaultExportProvider);

                bindingProvider.SourceProvider = this.container;
            }
            catch (Exception ex)
            {
                tracer.Error(ex, Resources.BindingCompositionService_FailedToInitialize);
                throw;
            }

            // Used by the CompositionServiceBindingContext to create a new CompositionContainer over
            // this one for dynamic context resolution.
            this.container.ComposeExportedValue <ExportProvider>(container);
        }
예제 #30
0
        protected override CompositionContainer CreateInstance()
        {
            string extensionsPath = Path.Combine(SettingsStore.StoragePath, ExtensionDirectory);

            if (!Directory.Exists(ExtensionDirectory))
            {
                Directory.CreateDirectory(ExtensionDirectory);
            }

            DirectoryCatalog thirdPartyCatelog = new DirectoryCatalog(ExtensionDirectory);
            AggregateCatalog defaultCatalog    = new AggregateCatalog();

            defaultCatalog.Catalogs.Add(new DirectoryCatalog("./", "Reshaper*.dll"));
            CatalogExportProvider defaultExportProvider = new CatalogExportProvider(defaultCatalog);

            CompositionContainer container = new CompositionContainer(thirdPartyCatelog, defaultExportProvider);

            defaultExportProvider.SourceProvider = container;
            return(container);
        }