C# CompositionContainer.GetExportedValueOrDefault方法代碼示例

		private static void ComposeConnectionFactory()
		{
			try
			{
				using (var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory))
				using (var container = new CompositionContainer(catalog))
				{
					var export = container.GetExportedValueOrDefault<IConnectionFactory>();
					if (export != null)
					{
						Factory = export;
						Console.WriteLine("Using {0}", Factory.GetType());
					}
				}
			}
			catch (ImportCardinalityMismatchException)
			{
				Console.WriteLine("More than one IConnectionFactory import was found.");
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			if (Factory == null)
			{
				Factory = new DefaultConnectionFactory();
				Console.WriteLine("Using default connection factory...");
			}
		}

       public StartTabPanelViewModel(CompositionContainer container)
       {
           timeline = container.GetExportedValueOrDefault<ITimeline>();
           AppState.StartPanelTabItems.CollectionChanged += StartPanelTabItemsCollectionChanged;
 
           AppState.FilteredStartTabItems.CollectionChanged += FilteredStartTabItems_CollectionChanged;
           AppState.ExcludedStartTabItems.CollectionChanged += ExcludedStartTabItems_CollectionChanged;
       }

        private static void InitializeContainer()
        {
            var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            container = new CompositionContainer(assemblyCatalog);

            featureConfig = container.GetExportedValueOrDefault<IFeatureConfiguration>();
            if (featureConfig == null)
            {
                throw new CompositionException("Could not find feature configuration part");
            }
        }

        /// <summary>
        /// Searches "Application Extensions" for and activates "*SplashScreen*.dll"
        /// </summary>
        /// <returns></returns>
        public static ISplashScreenManager GetSplashScreenManager()
        {
            // This is a specific directory where a splash screen may be located.
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Application Extensions");
            if (!Directory.Exists(path))
                return null;

            string file = Directory.EnumerateFiles(path, "*SplashScreen*.dll").FirstOrDefault();
            if (file == null) return null;

            using (AggregateCatalog splashCatalog = new AggregateCatalog())
            {
                splashCatalog.Catalogs.Add(new AssemblyCatalog(file));
                using (CompositionContainer splashBatch = new CompositionContainer(splashCatalog))
                {
                    var splash = splashBatch.GetExportedValueOrDefault<ISplashScreenManager>();
                    if (splash != null)
                        splash.Activate();
                    return splash;
                }
            }
        }

        /// <summary>
        /// Searches "Application Extensions" for and activates "*SplashScreen*.dll"
        /// </summary>
        /// <returns></returns>
        public static ISplashScreenManager GetSplashScreenManager()
        {
            // This is a specific directory where a splash screen may be located.
            Assembly asm = Assembly.GetEntryAssembly();
            var directories = new List<string> { AppDomain.CurrentDomain.BaseDirectory + "Application Extensions", 
                                                 AppDomain.CurrentDomain.BaseDirectory + "Plugins",
                                                 Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), asm.ManifestModule.Name, "Extensions"),
                                                 AppDomain.CurrentDomain.BaseDirectory + "Extensions"};

            foreach (string directory in directories)
            {
                if (!Directory.Exists(directory))
                    continue;

                string file = Directory.EnumerateFiles(directory, "*SplashScreen*.dll", SearchOption.AllDirectories).FirstOrDefault();
                if (file == null)
                    continue;

                using (AggregateCatalog splashCatalog = new AggregateCatalog())
                {
                    splashCatalog.Catalogs.Add(new AssemblyCatalog(file));

                    using (CompositionContainer splashBatch = new CompositionContainer(splashCatalog))
                    {
                        var splash = splashBatch.GetExportedValueOrDefault<ISplashScreenManager>();

                        if (splash != null)
                            splash.Activate();

                        return splash;
                    }
                }

            }

            return null;
        }

        public void TryToDiscoverExportWithGenericParameter()
        {
            var catalog = new TypeCatalog(Assembly.GetExecutingAssembly().GetTypes());
            var container = new CompositionContainer(catalog);

            // Open generic should fail because we should discover that type
            Assert.IsNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(ExportWithGenericParameter<>))));

            // This specific generic was not exported any where so it should fail
            Assert.IsNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(ExportWithGenericParameter<double>))));

            // This specific generic was exported so it should succeed
            Assert.IsNotNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(ExportWithGenericParameter<int>))));

            // Shouldn't discovoer static type with open generic
            Assert.IsNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(StaticExportWithGenericParameter<>))));

            // Should find a type that inherits from an export
            Assert.IsNotNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(ExportWhichInheritsFromGeneric))));

            // This should be exported because it is inherited by ExportWhichInheritsFromGeneric
            Assert.IsNotNull(container.GetExportedValueOrDefault<object>(AttributedModelServices.GetContractName(typeof(ExportWithGenericParameter<string>))));
        }

 public static TypeDescriptorServices GetTypeDescriptorServicesForContainer(CompositionContainer container)
 {
     if (container != null)
     {
         var result = container.GetExportedValueOrDefault<TypeDescriptorServices>();
         if (result == null)
         {
             var v = new TypeDescriptorServices();
             CompositionBatch batch = new CompositionBatch();
             batch.AddPart(v);
             container.Compose(batch);
             return v;
         }
         
         return result;
     }
     return null;
 }

        public void Disposing_catalog_should_dispose_parts_implementing_dispose_pattern()
        {
            var innerCatalog = new TypeCatalog(typeof(DisposablePart));
            var cfg = new InterceptionConfiguration();
            var catalog = new InterceptingCatalog(innerCatalog, cfg);
            container = new CompositionContainer(catalog);

            var part = container.GetExportedValueOrDefault<DisposablePart>();
            Assert.That(part.IsDisposed, Is.False);
            container.Dispose();
            Assert.That(part.IsDisposed, Is.True);
        }

        public ShellViewModel(CompositionContainer container)
        {
            // load visuals
            this.container = container;
            plugins = container.GetExportedValue<IPlugins>();
            popups = container.GetExportedValue<IPopups>();
            floating = container.GetExportedValueOrDefault<IFloating>();
            AppState.Container = this.container;
            AppState.FullScreenFloatingElementChanged += (e, s) => NotifyOfPropertyChange(() => FullScreen);
            
            // load module
            AppState.State = AppStates.Starting;

            //Load configuration
            AppState.Config.LoadOfflineConfig();
            AppState.Config.LoadLocalConfig();
            AppState.Config.UpdateValues();
            BackgroundWorker barInvoker = new BackgroundWorker();
            barInvoker.DoWork += delegate
            {
                Thread.Sleep(TimeSpan.FromSeconds(10));
                AppState.ViewDef.CheckOnlineBaseLayerProviders();
            };
            barInvoker.RunWorkerAsync();
            
            
            
            var b = container.GetExportedValues<IModule>();
            module = b.FirstOrDefault();
            if (module == null) return;

            AppState.Config.ApplicationName = module.Name;

            AppState.State = AppStates.AppInitializing;
            AppState.ViewDef.RememberLastPosition = AppState.Config.GetBool("Map.RememberLastPosition", true);

            AppState.MapStarted += (e, f) =>
            {
                AppState.StartFramework(true, true, true, true);

                AppState.ShareContracts.Add(new EmailShareContract());
                AppState.ShareContracts.Add(new QrShareContract());

                var g = AppState.AddDownload("Init", "StartPoint");

                // start framework
                AppState.State = AppStates.FrameworkStarting;
                AddMainMenuItems();

                // set map
                if (AppState.ViewDef.RememberLastPosition)
                {
                    var extent = (AppState.Config.Get("Map.Extent", "-186.09257071294,-101.374056570352,196.09257071294,204.374056570352"));
                    if (!string.IsNullOrEmpty(extent))
                        AppState.ViewDef.MapControl.Extent = (Envelope)new EnvelopeConverter().ConvertFromString(extent);
                }

                // start app
                AppState.State = AppStates.AppStarting;

                // init plugins


                module.StartApp();

                // app ready
                AppState.State = AppStates.AppStarted;
                AppState.Imb.UpdateStatus();
                AppState.FinishDownload(g);

                // Show timeline player (EV: I've tried to turn it on earlier during the startup process, but that didn't work 
                // (most likely, because something wasn't loaded or initialized correctly).
                AppState.TimelineManager.PlayerVisible = AppState.Config.GetBool("Timeline.PlayerVisible", false);
            };
            
            module.InitializeApp();

        }