public NetworkAwareCatalog(ComposablePartCatalog filteredCatalog)
        {
            _networkStatus = (NetworkInterface.GetIsNetworkAvailable()) ? "Online" : "Offline";
            NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkAvailabilityChanged);

            _filteredCatalog = filteredCatalog;
        }

 public FilteredCatalog(ComposablePartCatalog inner,
                        Func<ComposablePartDefinition, bool> filter)
 {
     _inner = inner;
     _innerNotifyChange = inner as INotifyComposablePartCatalogChanged;
     _partsQuery = inner.Parts.Where(filter).AsQueryable();
 }

        internal CompositionService(ComposablePartCatalog composablePartCatalog)
        {
            Assumes.NotNull(composablePartCatalog);
            this._notifyCatalog = composablePartCatalog as INotifyComposablePartCatalogChanged;
            try
            {
                if(this._notifyCatalog != null)
                {
                    this._notifyCatalog.Changing += this.OnCatalogChanging;
                }

                var compositionOptions = CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe | CompositionOptions.ExportCompositionService;
                var compositionContainer = new CompositionContainer(composablePartCatalog, compositionOptions);
    
                this._compositionContainer = compositionContainer;
            }
            catch
            {
                if(this._notifyCatalog != null)
                {
                    this._notifyCatalog.Changing -= this.OnCatalogChanging;
                }
                throw;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CompositionScopeDefinition"/> class.
        /// </summary>
        /// <param name="catalog">The catalog.</param>
        /// <param name="children">The children.</param>
        public CompositionScopeDefinition(ComposablePartCatalog catalog, IEnumerable<CompositionScopeDefinition> children)
        {
            Requires.NotNull(catalog, "catalog");
            Requires.NullOrNotNullElements(children, "children");

            InitializeCompositionScopeDefinition(catalog, children, null);
        }

 public GenericCatalog(ComposablePartCatalog catalog)
 {
     _decoratedCatalog = catalog;
     _catalog.Catalogs.Add(_decoratedCatalog);
     _catalog.Changing += (s, e) => { OnChanging(e); };
     LoadTypeLocators(_genericTypes);
 }

 public MefUnityContainerExtension(ComposablePartCatalog catalog, bool register, params ExportProvider[] providers)
 {
     Debug.Assert(catalog != null);
     m_Catalog = catalog;
     m_Register = register;
     m_Providers = providers;
 }

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="catalog"></param>
        /// <param name="exports"></param>
        Document(
            Func<Document, XDocument> xml,
            ComposablePartCatalog catalog,
            ExportProvider exports)
        {
            Contract.Requires<ArgumentNullException>(xml != null);

            // configure composition
            this.configuration = GetConfiguration(catalog, exports);
            this.container = new CompositionContainer(configuration.HostCatalog, true, new CompositionContainer(configuration.GlobalCatalog, true, configuration.Exports));
            this.container.GetExportedValue<DocumentEnvironment>().SetHost(this);

            // required services
            this.invoker = container.GetExportedValue<IInvoker>();
            this.trace = container.GetExportedValue<ITraceService>();

            // initialize xml
            this.xml = xml(this);
            this.xml.AddAnnotation(this);

            // parallel initialization of common interfaces
            Parallel.ForEach(this.xml.DescendantNodesAndSelf(), i =>
            {
                Enumerable.Empty<object>()
                    .Concat(i.Interfaces<IOnInit>())
                    .Concat(i.Interfaces<IOnLoad>())
                    .ToLinkedList();
            });

            // initial invocation entry
            this.invoker.Invoke(() => { });
        }

        public static async Task TouchCatalog(ComposablePartCatalog composablePartCatalog)
        {
            var aggregate = composablePartCatalog as AggregateCatalog;
            if (aggregate != null)
            {
                //foreach (var catalog in aggregate.Catalogs)
                //{
                //    TouchCatalog(catalog);
                //}

                var actionList = new List<Task>();
                foreach (var item in aggregate.Catalogs)
                {
                    actionList.Add(TouchCatalog(item));
                }

                await Task.WhenAll(actionList.ToArray());
            }
            else
            {
                var metadataAssemblyCatalog = composablePartCatalog as MetadataAssemblyCatalog;
                if (metadataAssemblyCatalog != null)
                {
                    await metadataAssemblyCatalog.Realize();
                }

                foreach (var part in composablePartCatalog.Parts)
                {
                    TouchPart(part);
                }
            }
        }

 public IQueryable<ComposablePart> SelectParts(ComposablePartCatalog catalog)
 {
     var parts = from part in catalog.Parts
                 where part.ExportDefinitions.Any(d => d.ContractName == typeof(IOperatorsPackage).FullName)
                 select part.CreatePart();
     return parts;
 }

    /// <summary>
    /// Initializes a new instance of the FilteredCatalog class with the specified underlying
    /// catalog and filter.
    /// </summary>
    public FilteredCatalog(ComposablePartCatalog inner,
		Expression<Func<ComposablePartDefinition, bool>> expression)
    {
        _inner = inner;
        _innerNotifyChange = inner as INotifyComposablePartCatalogChanged;
        _partsQuery = inner.Parts.Where(expression);
    }

 public MEFedMVVMExportProvider(ComposablePartCatalog catalog)
 {
     _exportProvider = new CatalogExportProvider(catalog);
     //support recomposition
     _exportProvider.ExportsChanged += (s, e) => OnExportsChanged(e); 
     _exportProvider.ExportsChanging += (s, e) => OnExportsChanging(e);
 }

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="scope"></param>
        public ScopeCatalog(ComposablePartCatalog parent, Scope scope)
            : base(parent, GetFilter(scope))
        {
            Contract.Requires<ArgumentNullException>(parent != null);

            this.scope = scope;
        }

        public ScopedContainerManager(ComposablePartCatalog rootCatalog)
        {
            if (rootCatalog == null) throw new ArgumentNullException("rootCatalog");

            _rootCatalog = rootCatalog;

            _container = new CompositionContainer(new FilteredCatalog(rootCatalog, def => GetAllWithinAppScope(def)), true);
        }

 /// <summary>
 /// Registers a MEF catalog within Unity container.
 /// </summary>
 /// <param name="unityContainer">Unity container instance.</param>
 /// <param name="catalog">MEF catalog to be registered.</param>
 /// <param name="isThreadSafe">Indicates if MEF should be thread safe.</param>
 public static void RegisterCatalog(this IUnityContainer unityContainer, ComposablePartCatalog catalog, bool isThreadSafe = false)
 {
     lock (unityContainer)
     {
         var compositionIntegration = EnableCompositionIntegration(unityContainer, isThreadSafe);
         compositionIntegration.Catalogs.Add(catalog);
     }
 }

 public CatalogChangeProxy(ComposablePartCatalog originalCatalog,
     IEnumerable<ComposablePartDefinition> addedParts,
     IEnumerable<ComposablePartDefinition> removedParts)
 {
     this._originalCatalog = originalCatalog;
     this._addedParts = new List<ComposablePartDefinition>(addedParts);
     this._removedParts = new HashSet<ComposablePartDefinition>(removedParts);
 }

        public ForceFieldContainer(ComposablePartCatalog catalog, Configuration config)
            : base(catalog)
        {
            Guard.ArgumentIsNotNull(() => catalog, () => config);

            _config = config;
            _config.SetInnerContainer(this);
        }

 public CatalogContractInformationProvider(ComposablePartCatalog catalog)
 {
     _catalog = catalog;
     var changeableCatalog = _catalog as INotifyComposablePartCatalogChanged;
     if (changeableCatalog != null)
     {
         changeableCatalog.Changed +=new EventHandler<ComposablePartCatalogChangeEventArgs>(catalog_Changed);
     }
 }

        public static CompositionContainer Create(ComposablePartCatalog catalog)
        {
            var container = new CompositionContainer(new AggregateCatalog(catalog,
                new TypeCatalog(typeof(CompositionContainer))));

            container.ComposeExportedValue<CompositionContainer>(container);

            return container;
        }

        public void Constructor3_ArrayWithNullAsCatalogsArgument_ShouldThrowArgument()
        {
            var catalogs = new ComposablePartCatalog[] { null };

            ExceptionAssert.ThrowsArgument<ArgumentException>("catalogs", () =>
            {
                new AggregateCatalog(catalogs);
            });
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProxyCatalog"/> class.
        /// </summary>
        /// <param name="innerCatalog">The inner catalog.</param>
        public ProxyCatalog(ComposablePartCatalog innerCatalog)
        {
            this.innerCatalog = innerCatalog;
			parts = CreateFrom(this.innerCatalog);
			
            var notifyingCatalog = this.innerCatalog as INotifyComposablePartCatalogChanged;
            if(notifyingCatalog != null)
                notifyingCatalog.Changing += NotifyingCatalog_Changing;
        }