Cake.Web.Docs.ExtensionMethodFinder.FindExtensionMethods C# (CSharp) Метод

        public List<DocumentedMethod> FindExtensionMethods(DocumentedType type)
        {
            var methods = new List<DocumentedMethod>();
            var current = type.Definition;
            while (current != null)
            {
                if (current.FullName == "System.Object")
                {
                    // Skip extension methods for System.Object.
                    break;
                }

                // Found extension methods for the current type?
                if (_lookup.ContainsKey(current.FullName))
                {
                    methods.AddRange(_lookup[current.FullName]);
                }

                // Found extension methods for the current types interfaces?
                foreach (var typeReference in current.Interfaces)
                {
                    if (_lookup.ContainsKey(typeReference.InterfaceType.FullName))
                    {
                        methods.AddRange(_lookup[typeReference.InterfaceType.FullName]);
                    }
                }

                // Get the base type.
                var baseType = current.BaseType;
                if (baseType != null)
                {
                    try
                    {
                        // Resolve the type.
                        current = baseType.Resolve();
                    }
                    catch (Exception)
                    {
                        // Resolution failed.
                        current = null;
                    }
                }
                else
                {
                    current = null;
                }
            }
            return methods;
        }

        /// <summary>
        /// Generates a document model from a <see cref="ReflectionModel"/>
        /// and a <see cref="XmlDocumentationModel"/>.
        /// </summary>
        /// <param name="reflectionModel">The reflection model.</param>
        /// <param name="xmlModel">The XML documentation model.</param>
        /// <returns>A document model.</returns>
        public static DocumentModel Map(ReflectionModel reflectionModel, XmlDocumentationModel xmlModel)
        {
            var assemblies = new List <DocumentedAssembly>();

            // Iterate all assemblies.
            foreach (var assembly in reflectionModel.Assemblies)
            {
                assemblies.Add(MapAssembly(assembly, xmlModel));
            }

            // Create the document model.
            var model = new DocumentModel(assemblies);

            // Map extension methods.
            var finder     = new ExtensionMethodFinder(model);
            var namespaces = model.Assemblies.SelectMany(a => a.Namespaces).ToArray();

            foreach (var @namespace in namespaces)
            {
                foreach (var type in @namespace.Types)
                {
                    type.SetExtensionMethods(finder.FindExtensionMethods(type));
                }
            }

            // Map base types methods.
            var baseTypeFinder = new BaseTypeFinder(model);

            foreach (var @namespace in namespaces)
            {
                foreach (var type in @namespace.Types)
                {
                    type.BaseType = baseTypeFinder.FindBaseType(type);
                }
            }

            // Build namespace trees and map them.
            var trees = DocumentedNamespaceTree.Build(namespaces);

            foreach (var @namespace in namespaces)
            {
                if (trees.ContainsKey(@namespace.Identity))
                {
                    @namespace.Tree = trees[@namespace.Identity];
                }
            }

            return(model);
        }