public IEnumerable Validate()

in src/Microsoft.VisualStudio.Composition/ComposedPart.cs [67:163]
84 lines of code
20 McCabe index (conditional complexity)

        public IEnumerable<ComposedPartDiagnostic> Validate(IReadOnlyDictionary<Type, ExportDefinitionBinding> metadataViews)
        {
            Requires.NotNull(metadataViews, nameof(metadataViews));

            if (this.Definition.ExportDefinitions.Any(ed => CompositionConfiguration.ExportDefinitionPracticallyEqual.Default.Equals(ExportProvider.ExportProviderExportDefinition, ed.Value)) &&
                !this.Definition.Equals(ExportProvider.ExportProviderPartDefinition))
            {
                yield return new ComposedPartDiagnostic(this, Strings.ExportOfExportProviderNotAllowed, this.Definition.Type.FullName);
            }

            var importsWithGenericTypeParameters = this.Definition.Imports
                .Where(import => import.ImportingSiteElementTypeRef.GenericTypeParameterCount != 0).ToList();
            foreach (var import in importsWithGenericTypeParameters)
            {
                yield return new ComposedPartDiagnostic(
                    this,
                    Strings.ImportsThatUseGenericTypeParametersNotSupported,
                    GetDiagnosticLocation(import));
            }

            foreach (var pair in this.satisfyingExports)
            {
                var importDefinition = pair.Key.ImportDefinition;
                switch (importDefinition.Cardinality)
                {
                    case ImportCardinality.ExactlyOne:
                        if (pair.Value.Count != 1)
                        {
                            yield return new ComposedPartDiagnostic(
                                this,
                                Strings.ExpectedExactlyOneExportButFound,
                                GetDiagnosticLocation(pair.Key),
                                GetImportConstraints(pair.Key.ImportDefinition),
                                pair.Value.Count,
                                GetExportsList(pair.Value));
                        }

                        break;
                    case ImportCardinality.OneOrZero:
                        if (pair.Value.Count > 1)
                        {
                            yield return new ComposedPartDiagnostic(
                                this,
                                Strings.ExpectedOneOrZeroExportsButFound,
                                GetDiagnosticLocation(pair.Key),
                                GetImportConstraints(pair.Key.ImportDefinition),
                                pair.Value.Count,
                                GetExportsList(pair.Value));
                        }

                        break;
                }

                foreach (var export in pair.Value)
                {
                    if (ReflectionHelpers.IsAssignableTo(pair.Key, export) == ReflectionHelpers.Assignability.DefinitelyNot)
                    {
                        yield return new ComposedPartDiagnostic(
                            this,
                            Strings.IsNotAssignableFromExportedMEFValue,
                            GetDiagnosticLocation(pair.Key),
                            GetDiagnosticLocation(export));
                    }

                    // Some parts exist exclusively for their metadata and the parts themselves are not instantiable.
                    // But that only makes sense if all importers do it lazily. If this part imports one of these
                    // non-instantiable parts in a non-lazy fashion, it's doomed to fail at runtime, so call it a graph error.
                    if (!pair.Key.IsLazy && !export.IsStaticExport && !export.PartDefinition.IsInstantiable)
                    {
                        // Special case around our export provider.
                        if (export.ExportDefinition != ExportProvider.ExportProviderExportDefinition)
                        {
                            yield return new ComposedPartDiagnostic(
                                this,
                                Strings.CannotImportBecauseExportingPartCannotBeInstantiated,
                                GetDiagnosticLocation(pair.Key),
                                GetDiagnosticLocation(export));
                        }
                    }
                }

                if (pair.Key.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore && pair.Key.ImportingParameterRef != null && !IsAllowedImportManyParameterType(pair.Key.ImportingParameterRef.Resolve().ParameterType))
                {
                    yield return new ComposedPartDiagnostic(this, Strings.ImportingCtorHasUnsupportedParameterTypeForImportMany);
                }

                var metadataType = pair.Key.MetadataType;
                if (metadataType != null && !metadataViews.ContainsKey(metadataType))
                {
                    yield return new ComposedPartDiagnostic(
                        this,
                        Strings.MetadataTypeNotSupported,
                        GetDiagnosticLocation(pair.Key),
                        metadataType.FullName);
                }
            }
        }