public virtual IEnumerable GetExports()

in src/Microsoft.VisualStudio.Composition/ExportProvider.cs [312:377]
53 lines of code
8 McCabe index (conditional complexity)

        public virtual IEnumerable<Export> GetExports(ImportDefinition importDefinition)
        {
            Requires.NotNull(importDefinition, nameof(importDefinition));

            if (importDefinition.ContractName == ExportProviderExportDefinition.ContractName)
            {
                return this.NonDisposableWrapperExportAsListOfOne;
            }

            bool isExportFactory = importDefinition.ContractName == CompositionConstants.PartCreatorContractName;
            ImportDefinition? exportFactoryImportDefinition = null;
            if (isExportFactory)
            {
                // This is a runtime request for an ExportFactory<T>. This can happen for example when an object
                // is supplied to a MEFv1 CompositionContainer's SatisfyImportsOnce method when that object
                // has an importing member of type ExportFactory<T>.
                // We must unwrap the nested import definition to unveil the actual export to be created
                // by this export factory.
                exportFactoryImportDefinition = importDefinition;
                importDefinition = (ImportDefinition)importDefinition.Metadata[CompositionConstants.ExportFactoryProductImportDefinition]!;
            }

            IEnumerable<ExportInfo> exportInfos = this.GetExportsCore(importDefinition);

            string? genericTypeDefinitionContractName;
            Type[]? genericTypeArguments;
            if (ComposableCatalog.TryGetOpenGenericExport(importDefinition, out genericTypeDefinitionContractName, out genericTypeArguments))
            {
                var genericTypeImportDefinition = new ImportDefinition(genericTypeDefinitionContractName, importDefinition.Cardinality, importDefinition.Metadata, importDefinition.ExportConstraints);
                var openGenericExports = this.GetExportsCore(genericTypeImportDefinition);
                var closedGenericExports = openGenericExports.Select(export => export.CloseGenericExport(genericTypeArguments));
                exportInfos = exportInfos.Concat(closedGenericExports);
            }

            var filteredExportInfos = from export in exportInfos
                                      where importDefinition.ExportConstraints.All(c => c.IsSatisfiedBy(export.Definition))
                                      select export;

            IEnumerable<Export> exports;
            if (exportFactoryImportDefinition is object)
            {
                var exportFactoryType = (Type?)exportFactoryImportDefinition.Metadata[CompositionConstants.ExportFactoryTypeMetadataName]!;
                exports = filteredExportInfos.Select(ei => this.CreateExportFactoryExport(ei, exportFactoryType));
            }
            else
            {
                exports = filteredExportInfos.Select(
                    fe => fe.HasNonSharedLifetime
                        ? new NonSharedExport(fe.Definition, fe.ExportedValueGetter)
                        : new Export(fe.Definition, () => fe.ExportedValueGetter().Value));
            }

            var exportsSnapshot = exports.ToArray(); // avoid repeating all the foregoing work each time this sequence is enumerated.
            if (importDefinition.Cardinality == ImportCardinality.ExactlyOne && exportsSnapshot.Length != 1)
            {
                throw new CompositionFailedException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        Strings.UnexpectedNumberOfExportsFound,
                        1,
                        importDefinition.ContractName,
                        exportsSnapshot.Length));
            }

            return exportsSnapshot;
        }