public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports)
        {
            if (definition == null) throw new ArgumentNullException("definition");
            if (exports == null) throw new ArgumentNullException("exports");

            InterceptedPart.SetImport(definition, exports);
        }

        public override System.Collections.Generic.IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition)
        {
            var exports = base.GetExports(definition);
            if (GalaSoft.MvvmLight.ViewModelBase.IsInDesignModeStatic)
            {
                var designExports = exports.Where(export => (export.Item2.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName) &&
                    ((bool)export.Item2.Metadata[DesignTimeExportAttribute.DesignTimeMetadataName]) == true));

                if (designExports.Count() > 0)
                {
                    exports = designExports;
                }
                else
                {
                    exports = from export in exports
                              let ed = export.Item2
                              where !ed.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName)
                              select export;
                }
            }
            else
            {
                exports = from export in exports
                          let ed = export.Item2
                          where !ed.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName) || ((bool)ed.Metadata[DesignTimeExportAttribute.DesignTimeMetadataName]) == false
                          select export;
            }
            var a = exports.ToArray();
            return exports;
        }

        /// <summary>
        /// Method which can filter exports for given <see cref="ImportDefinition"/> or produce new exports.
        /// </summary>
        /// <param name="definition"><see cref="ImportDefinition"/> instance.</param>
        /// <param name="exports">A collection of <see cref="ExportDefinition"/>
        /// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</param>
        /// <returns>A collection of <see cref="ExportDefinition"/>
        /// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</returns>
        public IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition, IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> exports)
        {
            if (exports.Any())
            {
                return exports;
            }

            if (!CompositionServices.IsReflectionImportDefinition(definition))
            {
                return Enumerable.Empty<Tuple<ComposablePartDefinition, ExportDefinition>>();
            }

            var returnedExports = new List<Tuple<ComposablePartDefinition, ExportDefinition>>();
            var importDefinitionType = CompositionServices.GetImportDefinitionType(definition);

            if (TypeHelper.IsGenericCollection(importDefinitionType))
            {
                importDefinitionType = TypeHelper.GetGenericCollectionParameter(importDefinitionType);
            }

            if (this.manufacturedParts.Contains(importDefinitionType))
            {
                returnedExports.AddRange(this.aggregateCatalog.GetExports(definition));
            }
            else if (TypeHelper.ShouldCreateClosedGenericPart(importDefinitionType))
            {
                CreateGenericParts(importDefinitionType);
                returnedExports.AddRange(this.aggregateCatalog.GetExports(definition));
            }

            return returnedExports;
        }

		protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
		{
			var serviceTypeName = definition.ContractName;
			if (serviceTypeName.IndexOf('.') == -1 ||
				serviceTypeName.StartsWith("System.") ||
				serviceTypeName.StartsWith("Clide."))
				return Enumerable.Empty<Export>();

			return serviceExports.GetOrAdd (serviceTypeName, contractName => {
				var serviceType = typeMap.GetOrAdd(contractName, typeName => MapType(typeName));
				if (serviceType == null)
					return Enumerable.Empty<Export>();

				// NOTE: if we can retrieve a valid instance of the service at least once, we 
				// assume we'll be able to retrieve it later on. Note also that we don't return 
				// the single retrieved instance from the export, but rather provide a function 
				// that does the GetService call every time, since we're caching the export but 
				// we don't know if the service can be safely cached.
				var service = services.GetService(serviceType);
				if (service == null)
					return Enumerable.Empty<Export>();

				return new Export[] { new Export(serviceTypeName, () => services.GetService(serviceType)) };
			});
		}

        /// <summary>
        /// Gets the available set of exports for the given import definition.
        /// </summary>
        /// <param name="definition">The defintion of the import.</param>
        /// <param name="atomicComposition">The atomic composition of the import.</param>
        /// <returns>The available set of exports for the given import definition.</returns>
        protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {
            Throw.IfArgumentNull(definition, "definition");
            if (SourceProvider == null)
                Throw.InvalidOperation(
                    string.Format(
                        CultureInfo.CurrentUICulture,
                        Resources.Exceptions.PropertyCannotBeNull,
                        "Sourceprovider"));

            var contractDefinition = definition as ContractBasedImportDefinition;
            if (contractDefinition == null
                || !contractDefinition.RequiredTypeIdentity.StartsWith(PartFactoryContractPrefix))
                return EmptyExports;

            var info = _definitionCache.Fetch(contractDefinition, () => new PartFactoryImport(contractDefinition));

            var exports = SourceProvider.GetExports(info.ImportDefinition, atomicComposition);
            var result = exports
                .Select(e => info.CreateMatchingExport(e.Definition, SourceProvider))
                .ToArray();

            foreach (var export in exports.OfType<IDisposable>())
                export.Dispose();

            return result;
        }

        public IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition, IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> exports)
        {
            var contractDef = (ContractBasedImportDefinition)definition;
            var returnedExports = new List<Tuple<ComposablePartDefinition, ExportDefinition>>();
            var importDefinitionType = TypeHelper.GetImportDefinitionType(definition);

            if (exports.Any())
            {
                return exports;
            }

            returnedExports.Concat(exports);

            if (this.manufacturedParts.Contains(importDefinitionType))
            {
                returnedExports.AddRange(this.catalog.GetExports(definition));
            }
            else if (TypeHelper.ShouldCreateClosedGenericPart(contractDef, importDefinitionType))
            {
                CreateGenericPart(importDefinitionType);
                returnedExports.AddRange(this.catalog.GetExports(definition));
            }

            return returnedExports;
        }

 public override IEnumerable<TempTuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition)
 {
     LambdaExpression lambda = definition.Constraint;
     if (lambda.Body is BinaryExpression)
     {
         BinaryExpression binaryExpression = (BinaryExpression)lambda.Body;
         if (binaryExpression.Left is MemberExpression && ((MemberExpression)binaryExpression.Left).Member.Name == "ContractName")
         {
             IList<IService> services = resolver.Resolve((string)((ConstantExpression)binaryExpression.Right).Value, TimeOut, definition.Cardinality == ImportCardinality.ZeroOrOne ? 0 : 1, definition.Cardinality == ImportCardinality.ZeroOrMore ? int.MaxValue : 1);
             foreach (IService service in services)
                 resolver_ServiceFound(service);
         }
     }
     var exports = new List<TempTuple<ComposablePartDefinition, ExportDefinition>>();
     foreach (var part in this.Parts.ToArray())
     {
         foreach (var export in part.ExportDefinitions)
         {
             if (definition.Constraint.Compile().Invoke(export))
             {
                 exports.Add(new TempTuple<ComposablePartDefinition, ExportDefinition>(part, export));
             }
         }
     }
     return exports;
 }

        protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {
            if (definition == null) throw new ArgumentNullException("definition");
            if (SourceProvider == null) throw new InvalidOperationException("SourceProvider must be set.");

            var cbid = definition as ContractBasedImportDefinition;

            if (cbid == null || !cbid.RequiredTypeIdentity.StartsWith(PartCreatorContractPrefix))
                return EmptyExports;

            var importInfo = _importDefinitionCache.GetOrCreate(
                cbid,
                () => new ExportFactoryImport(cbid));

            var sourceExports = SourceProvider
                .GetExports(importInfo.ProductImport, atomicComposition);

            var result = sourceExports
                .Select(e => importInfo.CreateMatchingExport(e.Definition, SourceProvider))
                .ToArray();

            foreach (var e in sourceExports.OfType<IDisposable>())
                e.Dispose();

            return result;
        }

        public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports)
        {
            Contract.Requires(definition != null);
            Contract.Requires(exports != null);

            throw new NotImplementedException();
        }

            public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports)
            {
                Requires.NotNull(definition, "definition");
                Requires.NotNullOrNullElements(exports, "exports");

                throw ExceptionBuilder.CreateImportDefinitionNotOnThisComposablePart("definition");
            }

            protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
            {
                List<Export> exports = new List<Export>();

                ImportDefinition queryImport = TranslateImport(definition);
                if (queryImport == null)
                {
                    return exports;
                }

                // go through the catalogs and see if there's anything there of interest
                foreach (CompositionScopeDefinition childCatalog in this._scopeDefinition.Children)
                {
                    foreach (var partDefinitionAndExportDefinition in childCatalog.GetExportsFromPublicSurface(queryImport))
                    {
                        using (var container = this.CreateChildContainer(childCatalog))
                        {
                            // We create a nested AtomicComposition() because the container will be Disposed and 
                            // the RevertActions need to operate before we Dispose the child container
                            using (var ac = new AtomicComposition(atomicComposition))
                            {
                                var childCatalogExportProvider = container.CatalogExportProvider;
                                if (!childCatalogExportProvider.DetermineRejection(partDefinitionAndExportDefinition.Item1, ac))
                                {
                                    exports.Add(this.CreateScopeExport(childCatalog, partDefinitionAndExportDefinition.Item1, partDefinitionAndExportDefinition.Item2));
                                }
                            }
                        }
                    }
                }

                return exports;
            }

        protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {
            var contractName = definition.ContractName;

            if (contractName != SettingsConstants.SettingsContract)
                yield break;

            if (definition.Cardinality == ImportCardinality.ZeroOrMore)
                yield break;

            // TODO can't figure out how to get data injected into the Metadata collection
            //string settingsKey = definition.Metadata[SettingsConstants.SettingsMetadataKey] as string;

            LazyMemberInfo lazyMember = ReflectionModelServices.GetImportingMember(definition);
            MemberInfo member = lazyMember.GetAccessors().First();

            MethodInfo getterOrSetter = (MethodInfo)member;
            
            // HACK this is pretty evil
            PropertyInfo propInfo = getterOrSetter.DeclaringType.GetProperty(getterOrSetter.Name.Substring(4));

            ImportSettingAttribute settingsAttr = propInfo.GetCustomAttribute<ImportSettingAttribute>();

            if (settingsAttr == null)
                yield break;

            object value;
            if (!this._settingsProvider.TryGetValue(settingsAttr.SettingsKey, out value))
                yield break;

            yield return new Export(SettingsConstants.SettingsContract, () => value);
        }

        private static ImportDefinition TranslateImport(ImportDefinition import, ComposablePartDefinition part)
        {
            ContractBasedImportDefinition contractBasedImport = import as ContractBasedImportDefinition;
            if (contractBasedImport == null)
            {
                return import;
            }

            int[] importParametersOrder = contractBasedImport.Metadata.GetValue<int[]>(CompositionConstants.GenericImportParametersOrderMetadataName);
            if (importParametersOrder == null)
            {
                return import;
            }

            int partArity = part.Metadata.GetValue<int>(CompositionConstants.GenericPartArityMetadataName);
            if (partArity == 0)
            {
                return import;
            }

            string contractName = GenericServices.GetGenericName(contractBasedImport.ContractName, importParametersOrder, partArity);
            string requiredTypeIdentity = GenericServices.GetGenericName(contractBasedImport.RequiredTypeIdentity, importParametersOrder, partArity);
            return new ContractBasedImportDefinition(
                         contractName,
                         requiredTypeIdentity,
                         contractBasedImport.RequiredMetadata,
                         contractBasedImport.Cardinality,
                         contractBasedImport.IsRecomposable,
                         false,
                         contractBasedImport.RequiredCreationPolicy,
                         contractBasedImport.Metadata);
        }

        /// <summary>
        /// Returns the available exports for the specified import definition.
        /// </summary>
        /// <param name="definition">The import definition.</param>
        /// <returns>The set of matching exports.</returns>
        public override IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition)
        {
            var definitions = _catalog.GetExports(definition);

            var list = HttpContext.Current.ModelList<ImportDescriptor>("MEF-Imports");

            var model = new ImportDescriptor
                            {
                                Cardinality = definition.Cardinality.ToString(),
                                ContractName = definition.ContractName,
                                Prerequisite = definition.IsPrerequisite,
                                Recomposable = definition.IsRecomposable
                            };

            foreach (var def in definitions)
            {
                var meta = def.Item2.Metadata.Keys
                    .Where(k => k != CreationPolicyTypeName)
                    .ToDictionary(key => key, key => def.Item2.Metadata[key].ToString());

                string policy = null;
                if (def.Item2.Metadata.ContainsKey(CreationPolicyTypeName))
                    policy = def.Item2.Metadata[CreationPolicyTypeName].ToString();

                var export = new ExportDescriptor { CreationPolicy = policy, DisplayName = def.Item1.ToString(), Metadata = meta };

                model.Exports.Add(export);
            }

            list.Add(model);

            return definitions;
        }

        public IDictionary<string, object> CacheImportDefinition(ComposablePartDefinition owner, ImportDefinition importDefinition)
        {
            ContractBasedImportDefinition contractBasedImport = importDefinition as ContractBasedImportDefinition;
            Assumes.NotNull(contractBasedImport);

            return CompositionCacheServices.WriteImportDefinition(owner, contractBasedImport);
        }

        protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {
            if (definition.Cardinality != ImportCardinality.ExactlyOne)
            {
                return Enumerable.Empty<Export>();
            }

            ExportSource exportSource;
            if (_exactlyOneExports.TryGetValue(definition.ContractName, out exportSource))
            {
                AddMemberType(exportSource, definition);
                return new[] { exportSource.Export };
            }

            string typeName = ImportDefinitionConstraintAnalyser.GetRequiredTypeIdentity(definition.Constraint);
            Type type = GetType(typeName);
            if (!CanHandleType(type))
            {
                return Enumerable.Empty<Export>();
            }

            exportSource = new ExportSource(definition.ContractName, definition.Metadata);
            exportSource.AddType(type);
            AddMemberType(exportSource, definition);

            _exactlyOneExports[definition.ContractName] = exportSource;
            return new[] { exportSource.Export };
        }

        protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {

            if (definition.ContractName.Equals(typeof(ILogger).FullName))
            {
                yield return new Export(definition.ContractName, () => new Logger() { Header = "Factory - " });
            }
        }

        public static Type GetParameterType(ImportDefinition definition)
        {
            var importingParameter = ReflectionModelServices.GetImportingParameter(definition);
            var parameterInfo = importingParameter.Value;
            var importDefinitionType = parameterInfo.ParameterType;

            return importDefinitionType;
        }

 public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports) {
     if (_composablePart.IsValueCreated ||
         _imports == null) {
         _composablePart.Value.SetImport(definition, exports);
     } else {
         _imports.Add(definition, exports);
     }
 }

        protected override System.Collections.Generic.IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
        {
            var type = Type.GetType(definition.ContractName);
            Export e;
            var exports = base.GetExportsCore(definition, atomicComposition);

            return exports;
        }