public CatalogExport(CatalogExportProvider catalogExportProvider,
     ComposablePartDefinition partDefinition, ExportDefinition definition)
 {
     this._catalogExportProvider = catalogExportProvider;
     this._partDefinition = partDefinition;
     this._definition = definition;
 }

 public PartCreatorExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition exportDefinition)
 {
     this._catalogExportProvider = catalogExportProvider;
     this._partDefinition = partDefinition;
     this._exportDefinition = exportDefinition;
     this._partCreatorExportDefinition = new PartCreatorExportDefinition(this._exportDefinition);
 }

        public ExportingMember(ExportDefinition definition, ReflectionMember member)
        {
            Assumes.NotNull(definition, member);

            this._definition = definition;
            this._member = member;
        }

        protected bool IsMatch(ExportDefinition exportDefinition)
        {
            // If the feature is not enabled don't allow it
            if (exportDefinition.Metadata.ContainsKey("EnabledFeatures"))
            {
                if (!EnabledFeatures.IsEnabled((string)exportDefinition.Metadata["EnabledFeatures"]))
                {
                    return false;
                }
            }

            // If the feature is turned off in the options don't allow it
            if (exportDefinition.Metadata.ContainsKey("FeatureEnabled"))
            {
                if (!OptionApi.GetBool((string)exportDefinition.Metadata["FeatureEnabled"]))
                {
                    return false;
                }
            }

            if (exportDefinition.Metadata.ContainsKey("SupportedApplication"))
            {
                var applicationType = ((ApplicationType)exportDefinition.Metadata["SupportedApplication"]);
                return applicationType.HasFlag(_applicationType);
            }

            return false;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="XElementExportProvider"/> class.
        /// Includes *.xml and *.config by default.
        /// </summary>
        /// <param name="path">The path. Defaults to Directory.GetCurrentDirectory()</param>
        /// <param name="filters">A list of additional file filters to include.</param>
        public XElementExportProvider(string path = null, IEnumerable<string> filters = null)
        {
            if (path == null)
            {
                path = Directory.GetCurrentDirectory();
            }
            List<string> include = new List<string>(new[] { "*.xml", "*.config" });
            if (filters != null)
            {
                foreach (string filter in filters.Where(filter => !string.IsNullOrWhiteSpace(filter)).Where(filter => !include.Contains(filter)))
                {
                    include.Add(filter);
                }
            }

            List<string> xmlFiles = new List<string>(include.SelectMany(ext => Directory.GetFiles(path, ext)));

            _exportsDictionary = xmlFiles.Select(filePath => new FileInfo(filePath)).ToDictionary(
                fileInfo => fileInfo.Name,
                fileInfo =>
                {
                    ExportDefinition def = new ExportDefinition(fileInfo.Name, null);
                    Export e = new Export(def, () => XElement.Load(fileInfo.FullName));
                    return e;
                });
        }

        public static CompositionException CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException)
        {
            Assumes.NotNull(part, definition, innerException);

            return new CompositionException(
                ErrorBuilder.CreateCannotGetExportedValue(part, definition, innerException));
        }

        protected WebScopedComposablePart(ComposablePart composablePart)
        {
            _composablePart = composablePart;

            _exportDef = composablePart.ExportDefinitions.First();
            _key = ((string)_exportDef.Metadata["ExportTypeIdentity"]).Replace('.', '_');
        }

 /// <summary>
 /// Initializes the context from a part and the export.
 /// </summary>
 internal DecoratedExport(ComposablePartDefinition part, ExportDefinition export)
 {
     this.ExportDefinition = export;
     this.ExportingMember = ReflectionModelServices.GetExportingMember(export);
     this.ExportingType = ReflectionModelServices.GetPartType(part);
     this.NewMetadata = new Dictionary<string, object>(export.Metadata);
 }

 public override bool IsConstraintSatisfiedBy(ExportDefinition exportDefinition)
 {
     if (!base.IsConstraintSatisfiedBy(exportDefinition))
     {
         return false;
     }
     return PartCreatorExportDefinition.IsProductConstraintSatisfiedBy(this._productImportDefinition, exportDefinition);
 }

        public override object GetExportedObject(ExportDefinition definition)
        {
            Guard.Against(!definition.Equals(_export.Definition),
                          Resources.Error_PartDoesNotContainAnExportForContract,
                          definition.ContractName);

            return _export.GetExportedObject();
        }

        public ReflectionMemberExportDefinition(LazyMemberInfo member, ExportDefinition exportDefinition, ICompositionElement origin)
        {
            Assumes.NotNull(exportDefinition);

            this._member = member;
            this._exportDefinition = exportDefinition;
            this._origin = origin;
        }

 public void GetExportedObject_Guards_Against_Non_Matching_ExportDefinition()
 {
     object expected = new object();
     Export export = new Export("Foo", new Dictionary<string, object>(), () => expected);
     ExportDefinition nonMatching = new ExportDefinition("Bar", new Dictionary<string, object>());
     ExceptionAssert.Guards(() => new SingleExportComposablePart(export).GetExportedObject(nonMatching),
                            TargetResources.Error_PartDoesNotContainAnExportForContract, nonMatching.ContractName);
 }

        public void Constructor2_NullAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()
        {
            var definition = new ExportDefinition("Contract", (IDictionary<string, object>)null);

            ExceptionAssert.Throws<NotSupportedException>(() =>
            {
                definition.Metadata["Value"] = "Value";
            });
        }

            public override object GetExportedValue(ExportDefinition definition)
            {
                Requires.NotNull(definition, "definition");

                if (definition != _export.Definition)
                {
                    throw ExceptionBuilder.CreateExportDefinitionNotOnThisComposablePart("definition");
                }

                return _export.Value;
            }

        public override object GetExportedValue(ExportDefinition definition)
        {
            if (definition == null)
                throw new ArgumentNullException("definition");

            var rdef = (RubyExportDefinition)definition;

            var instance = GetOrCreateInstance();

            return rdef.GetExportedObject(instance);
        }

 protected override bool IsMatch(ExportDefinition exportDefinition)
 {
     object bundle;
     if (exportDefinition.Metadata.TryGetValue("Bundle", out bundle))
     {
         var bundleName = bundle as string;
         if (bundleName != null)
             return Bundles.Contains(bundleName, StringComparer.OrdinalIgnoreCase);
     }
     return base.IsMatch(exportDefinition);
 }

        public void Constructor2_ValueAsContractNameArgument_ShouldSetContractNameProperty()
        {
            var expectations = Expectations.GetContractNames();

            foreach (var e in expectations)
            {
                var definition = new ExportDefinition(e, new Dictionary<string, object>());

                Assert.AreEqual(e, definition.ContractName);
            }
        }

        public override object GetExportedValue(ExportDefinition exportDefinition)
        {
            exportDefinition.ShouldNotBeNull("exportDefinition");

            if (_values.ContainsKey(exportDefinition))
                return _values[exportDefinition];

            var value = InterceptedPart.GetExportedValue(exportDefinition);
            var interceptingValue = _valueInterceptor.Intercept(value);
            _values.Add(exportDefinition, interceptingValue);
            return interceptingValue;
        }

 internal static bool IsImportDependentOnPart(this ImportDefinition import, ComposablePartDefinition part, ExportDefinition export, bool expandGenerics)
 {
     import = import.GetProductImportDefinition();
     if (expandGenerics)
     {
         return part.GetExports(import).Any();
     }
     else
     {
         return TranslateImport(import, part).IsConstraintSatisfiedBy(export);
     }
 }

 public ApplicationSettingExportProvider(IDictionary<string, string> settings)
 {
     exports = new List<Export>();
     foreach (var key in settings.Keys)
     {
         var metadata = new Dictionary<string, object>();
         metadata.Add(CompositionConstants.ExportTypeIdentityMetadataName, typeof(string).FullName);
         var value = settings[key];
         var exportDefinition = new ExportDefinition(key, metadata);
         exports.Add(new Export(exportDefinition, () => value));
     }
 }