public SafeDirectoryCatalog(string path)
        {
            exceptions = new List<Exception>();
            var files = Directory.EnumerateFiles(GetFullPath(path), "*.dll", SearchOption.AllDirectories);

            aggregateCatalog = new AggregateCatalog();

            foreach (var file in files)
            {
                try
                {
                    var assemblyCatalog = new AssemblyCatalog(file);

                    if (assemblyCatalog.Parts.ToList().Count > 0)
                        aggregateCatalog.Catalogs.Add(assemblyCatalog);
                }
                catch (ReflectionTypeLoadException ex)
                {
                    foreach (var exception in ex.LoaderExceptions)
                    {
                        exceptions.Add(exception);
                    }
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }
        }

        public Bootstrapper()
        {
            var catalog = new AssemblyCatalog(typeof(Bootstrapper).Assembly);
            var compositionContainer = new CompositionContainer(catalog);

            compositionContainer.ComposeParts(this);
        }

    private void InitializePlugins()
    {
      // We look for plugins in our own assembly and in any DLLs that live next to our EXE.
      // We could force all plugins to be in a "Plugins" directory, but it seems more straightforward
      // to just leave everything in one directory
      var builtinPlugins = new AssemblyCatalog(GetType().Assembly);
      var externalPlugins = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
      
      _catalog = new AggregateCatalog(builtinPlugins, externalPlugins);
      _container = new CompositionContainer(_catalog);

      try
      {
        _container.SatisfyImportsOnce(this);       
      }
      catch (CompositionException ex)
      {
        if (_log.IsErrorEnabled)
        {
          _log.ErrorFormat("MEF Composition Exception: {0}", ex.Message);

          var errors = String.Join("\n    ", ex.Errors.Select(x => x.Description));
          _log.ErrorFormat("Composition Errors: {0}", errors);
        }
        throw;
      }
    }

 public TreatyHelper()
 {
     var catalog = new AssemblyCatalog(this.GetType().Assembly);
     var container = new CompositionContainer(catalog);
     
     this.treaties = container.GetExports<ITreatyProvider>().ToList();
 }

        public void Compose()
        {
            AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());

            string executionPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            string generatorsPath = Path.Combine(executionPath, "Generators");
            CreatePathIfRequied(generatorsPath);
            generatorsCatalog = new DirectoryCatalog(generatorsPath);

            string uiPath = Path.Combine(executionPath, "UI");
            CreatePathIfRequied(uiPath);
            UICatalog = new DirectoryCatalog(uiPath);

            AggregateCatalog catalog = new AggregateCatalog();
            catalog.Catalogs.Add(generatorsCatalog);
            catalog.Catalogs.Add(UICatalog);

            //Set the defaults....
            CatalogExportProvider mainProvider = new CatalogExportProvider(assemblyCatalog);
            CompositionContainer container = new CompositionContainer(catalog, mainProvider);
            mainProvider.SourceProvider = container;

            var batch = new CompositionBatch();
            batch.AddPart(this);

            RefreshCatalog refreshCatalog = new RefreshCatalog(generatorsCatalog, UICatalog);
            container.ComposeParts(refreshCatalog);
            container.Compose(batch);

            Logger.Write("Compose complete");
        }

        public SafeDirectoryCatalog(string directory)
        {
            var files = Directory.EnumerateFiles(directory, "*.dll", SearchOption.AllDirectories);

            _catalog = new AggregateCatalog();

            foreach (var file in files)
            {
                try
                {
	                var asmCat = new AssemblyCatalog(file);

	                //Force MEF to load the plugin and figure out if there are any exports
	                // good assemblies will not throw the RTLE exception and can be added to the catalog
	                if (asmCat.Parts.ToList().Count > 0) _catalog.Catalogs.Add(asmCat);
                }
                catch (ReflectionTypeLoadException)
                {
                }
                catch (BadImageFormatException)
                {
                }
                catch (FileLoadException) //ignore when the assembly load failed.
                {

                }
            }
        }

        public ModuleLoader(IAssemblyResolver resolver, ILog logger, Action<Assembly, AggregateCatalog> addToCatalog, Func<CompositionContainer, IEnumerable<Lazy<IModule, IModuleMetadata>>> getLazyModules, IFileSystem fileSystem, IAssemblyUtility assemblyUtility)
        {
            _resolver = resolver;
            _logger = logger;

            if (addToCatalog == null)
            {
                addToCatalog = (assembly, catalog) =>
                {
                    try
                    {
                        var assemblyCatalog = new AssemblyCatalog(assembly);
                        catalog.Catalogs.Add(assemblyCatalog);
                    }
                    catch (Exception exception)
                    {
                        logger.DebugFormat("Module Loader exception: {0}", exception.Message);
                    }
                };
            }

            _addToCatalog = addToCatalog;

            if (getLazyModules == null)
            {
                getLazyModules = container => container.GetExports<IModule, IModuleMetadata>();
            }

            _getLazyModules = getLazyModules;
            _fileSystem = fileSystem;
            _assemblyUtility = assemblyUtility;
        }

        public BlacklistedSafeDirectoryCatalog(IEnumerable<string> paths, IEnumerable<string> typesBlacklist)
        {
            Exceptions = new List<Exception>();
            TypesBlacklist = typesBlacklist;

            AggregateCatalog = new AggregateCatalog();

            foreach (var path in paths)
            {
                var files = Directory.EnumerateFiles(GetFullPath(path), "*.dll", SearchOption.AllDirectories);

                foreach (var file in files)
                {
                    try
                    {
                        var assemblyCatalog = new AssemblyCatalog(file);

                        if (assemblyCatalog.Parts.ToList().Count > 0)
                            AggregateCatalog.Catalogs.Add(assemblyCatalog);
                    }
                    catch (ReflectionTypeLoadException ex)
                    {
                        foreach (var exception in ex.LoaderExceptions)
                        {
                            Exceptions.Add(exception);
                        }
                    }
                    catch (Exception ex)
                    {
                        Exceptions.Add(ex);
                    }
                }
            }
        }

        public static void ComposeParts(params object[] attributedParts)
        {
            try
            {

                AssemblyCatalog catalog = new AssemblyCatalog(typeof(PluginLocator).Assembly);

                AggregateCatalog catalogs = new AggregateCatalog(catalog);
                var pluginDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "plugins");
                if (Directory.Exists(pluginDirectory))
                {
                    DirectoryCatalog dirCatalog = new DirectoryCatalog(pluginDirectory);
                    catalogs.Catalogs.Add(dirCatalog);
                }

                //pluginDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
                //if (Directory.Exists(pluginDirectory))
                //{
                //    DirectoryCatalog dirCatalog = new DirectoryCatalog(pluginDirectory);
                //    catalogs.Catalogs.Add(dirCatalog);
                //}

                CompositionContainer container = new CompositionContainer(catalogs);

                container.ComposeParts(attributedParts);

            }
            catch (Exception)
            {
                System.Diagnostics.Debugger.Break();
                throw;
            }
        }

 internal static void RegisterMef(HttpConfiguration config)
 {
     var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
     var container = new CompositionContainer(catalog);
     var resolver = new MefDependencyResolver(container);
     config.DependencyResolver = resolver;
 }

        public static ServerEntry LoadServer(string path)
        {
            try
            {
                //  Create a server entry for the server.
                var serverEntry = new ServerEntry();

                //  Set the data.
                serverEntry.ServerName = Path.GetFileNameWithoutExtension(path);
                serverEntry.ServerPath = path;

                //  Create an assembly catalog for the assembly and a container from it.
                var catalog = new AssemblyCatalog(Path.GetFullPath(path));
                var container = new CompositionContainer(catalog);

                //  Get the exported server.
                var server = container.GetExport<ISharpShellServer>().Value;

                serverEntry.ServerType = server.ServerType;
                serverEntry.ClassId = server.GetType().GUID;
                serverEntry.Server = server;

                return serverEntry;
            }
            catch (Exception)
            {
                //  It's almost certainly not a COM server.
                MessageBox.Show("The file '" + Path.GetFileName(path) + "' is not a SharpShell Server.", "Warning");
                return null;
            }
        }

        public void ComposeWithTypesExportedFromPythonAndCSharp(
            object compositionTarget,
            string scriptsToImport,
            params Type[] typesToImport)
        {
            ScriptSource script;
            var engine = Python.CreateEngine();
            using (var scriptStream = GetType().Assembly.
                GetManifestResourceStream(GetType(), scriptsToImport))
            using (var scriptText = new StreamReader(scriptStream))
            {
                script = engine.CreateScriptSourceFromString(scriptText.ReadToEnd());
            }

            var typeExtractor = new ExtractTypesFromScript(engine);
            var exports = typeExtractor.GetPartsFromScript(script, typesToImport).ToList();

            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());

            var container = new CompositionContainer(catalog);
            var batch = new CompositionBatch(exports, new ComposablePart[] { });
            container.Compose(batch);

            container.SatisfyImportsOnce(compositionTarget);
        }

 private static IList<ISpellCast> GetSpells()
 {
     // Use MEF to locate the content providers in this assembly
     var catalog = new AssemblyCatalog(typeof(SpellManager).Assembly);
     var compositionContainer = new CompositionContainer(catalog);
     return compositionContainer.GetExportedValues<ISpellCast>().ToList();
 }

    /// <summary>
    /// Initializes a new instance of the <see cref="SafeDirectoryCatalog" /> class.
    /// </summary>
    /// <param name="directory">The directory.</param>
    public SafeDirectoryCatalog( string directory )
    {
        var files = Directory.EnumerateFiles( directory, "*.dll", SearchOption.AllDirectories );

        _catalog = new AggregateCatalog();

        foreach ( var file in files )
        {
            try
            {
                var asmCat = new AssemblyCatalog( file );

                //Force MEF to load the plugin and figure out if there are any exports
                // good assemblies will not throw the RTLE exception and can be added to the catalog
                if ( asmCat.Parts.ToList().Count > 0 )
                    _catalog.Catalogs.Add( asmCat );
            }

            catch ( ReflectionTypeLoadException e)
            {
                //TODO: Add error logging
                string msg = e.Message;
            }
        }
    }

 private void App_OnStartup(object sender, StartupEventArgs e)
 {
     var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
     var container = new CompositionContainer(catalog);
     var mainWindow = container.GetExportedValue<MainWindow>();
     mainWindow.Show();
 }

        public void runs_script_with_operations_from_both_csharp_and_python()
        {
            var currentAssemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            var ironPythonScriptCatalog = new IronPythonScriptCatalog(
                new CompositionHelper().GetResourceScript("Operations.Python.py"),
                typeof (IMathCheatSheet), typeof (IOperation));

            var masterCatalog = new AggregateCatalog(currentAssemblyCatalog, ironPythonScriptCatalog);

            var container = new CompositionContainer(masterCatalog);
            var mathWiz = container.GetExportedValue<MathWizard>();

            const string mathScript =
            @"fib 6
            fac 6
            abs -99
            pow 2 4
            crc 3
            ";
            var results = mathWiz.ExecuteScript(mathScript).ToList();
            Assert.AreEqual(5, results.Count);
            Assert.AreEqual(8, results[0]);
            Assert.AreEqual(720, results[1]);
            Assert.AreEqual(99f, results[2]);
            Assert.AreEqual(16m, results[3]);
            Assert.AreEqual(9.4247782230377197d, results[4]);
        }

        public void Init()
        {
            try
              {
            AggregateCatalog catalog = new AggregateCatalog();

            var c1 = new DirectoryCatalog("Extensions");
            c1.Refresh();
            var c2 = new DirectoryCatalog("EventHandlers");
            c2.Refresh();
            var c3 = new AssemblyCatalog(Assembly.GetExecutingAssembly());

            catalog.Catalogs.Add(c1);
            catalog.Catalogs.Add(c2);
            catalog.Catalogs.Add(c3);

            CompositionContainer container = new CompositionContainer(catalog);
            container.ComposeParts(this);
              }
              catch (Exception ex)
              {
            WindowsLogWriter.LogMessage("Error occurred while composing Denso Extensions", System.Diagnostics.EventLogEntryType.Error);
            WindowsLogWriter.LogException(ex);
              }

              foreach (var plugin in Extensions)
              {
            plugin.Init();
              }

              EventHandlerManager.AnalyzeCommandHandlers(ImportedHandlers);
        }

        protected override void OnStartup( StartupEventArgs e )
        {
            base.OnStartup( e );

            new UnhandledExceptionHook( this );

            Application.Current.Exit += OnShutdown;

            var catalog = new AssemblyCatalog( GetType().Assembly );
            myContainer = new CompositionContainer( catalog, CompositionOptions.DisableSilentRejection );

            myContainer.Compose( new CompositionBatch() );

            var shell = myContainer.GetExportedValue<Shell>();

            myContainer.SatisfyImportsOnce( shell.myDesigner );

            ( ( Shell )MainWindow ).myProperties.DataContext = shell.myDesigner.SelectionService;

            Application.Current.MainWindow = shell;
            Application.Current.MainWindow.Show();

            var args = Environment.GetCommandLineArgs();
            if( args.Length == 2 )
            {
                shell.myDesigner.Open( args[ 1 ] );
            }
        }

        public SafeDirectoryCatalog(string directoryPath, string assemblyName = "")
        {
            var files = Directory.EnumerateFiles(directoryPath, "*.dll", SearchOption.AllDirectories);

            _catalog = new AggregateCatalog();

            foreach (var file in files)
            {
                if (!string.IsNullOrEmpty(assemblyName) && !file.Contains(assemblyName + ".dll"))
                    continue;

                try
                {
                    var asmCat = new AssemblyCatalog(file);

                    //Force MEF to load the plugin and figure out if there are any exports
                    // good assemblies will not throw the RTLE exception and can be added to the catalog
                    _catalog.Catalogs.Add(asmCat);
                }
                catch (BadImageFormatException)
                {
                    Console.WriteLine("Ignoring file: " + file);
                }
                catch (ReflectionTypeLoadException)
                {
                    Console.WriteLine("Ignoring file: " + file);
                }
                catch (FileLoadException)
                {
                    Console.WriteLine("Ignoring file: " + file);
                }
            }
        }

 private void ComposeConfiguration()
 {
     _configuration = new Configuration();
     var catalog = new AssemblyCatalog(Assembly.GetEntryAssembly());
     var container = new CompositionContainer(catalog);
     container.ComposeParts(_configuration);
 }