Beispiel #1
0
        /// <summary>
        /// Collect all namespaces from type descriptor.
        /// </summary>
        /// <param name="type">Type descriptor to inspect.</param>
        private void CollectTypeImports(IType type)
        {
            // skip aliased types
            if (_languageProvider.GetAlias(type) != null)
            {
                return;
            }

            if (type.Kind == TypeKind.Array)
            {
                CollectTypeImports(type.ArrayElementType !);
                return;
            }

            if (type.Parent != null)
            {
                CollectTypeImports(type.Parent);
                return;
            }

            if (type.Kind == TypeKind.Generic)
            {
                foreach (var typeArg in type.TypeArguments !)
                {
                    CollectTypeImports(typeArg);
                }
            }

            if (type.Namespace != null && !_ignoredImports.Contains(type.Namespace))
            {
                _imports.Add(type.Namespace);
            }
        }
Beispiel #2
0
        private void Render(
            EncodedStringBuilder builder,
            ILanguageProvider language,
            TypeSignature signature,
            TypeRenderOption options,
            bool isWritingLink)
        {
            var needToCloseLink = false;
            var documentedType  = _model.FindType(signature.Identity);

            // Writing link?
            if ((options & TypeRenderOption.Link) == TypeRenderOption.Link)
            {
                if (!isWritingLink && documentedType != null)
                {
                    if (signature.Url != null)
                    {
                        isWritingLink = needToCloseLink = true;
                        builder.AppendRaw("<a href=\"{0}\">", signature.Url);
                    }
                }
            }

            // Write type namespace?
            if ((options & TypeRenderOption.Namespace) == TypeRenderOption.Namespace)
            {
                builder.AppendEncoded(signature.Namespace.Name);

                if ((options & TypeRenderOption.Namespace) == TypeRenderOption.Namespace)
                {
                    builder.AppendEncoded(".");
                }
            }

            // Write type name?
            if ((options & TypeRenderOption.Name) == TypeRenderOption.Name)
            {
                var alias = language.GetAlias(signature.Identity);
                var name  = alias ?? signature.Name;
                builder.AppendEncoded(name);
            }

            if (signature.GenericArguments.Count != 0)
            {
                // Write generic arguments.
                builder.AppendEncoded("<");
                var result = new List <string>();
                foreach (var argument in signature.GenericArguments)
                {
                    result.Add(argument);
                }
                builder.AppendEncoded(string.Join(", ", result));
                builder.AppendEncoded(">");
            }
            else if (signature.GenericParameters.Count != 0)
            {
                // Write generic parameters.
                builder.AppendEncoded("<");
                var result = new List <string>();
                foreach (var parameter in signature.GenericParameters)
                {
                    Render(builder, language, parameter, options, isWritingLink);
                }
                builder.AppendEncoded(string.Join(", ", result));
                builder.AppendEncoded(">");
            }

            // Writing link?
            if ((options & TypeRenderOption.Link) == TypeRenderOption.Link)
            {
                if (needToCloseLink)
                {
                    builder.AppendRaw("</a>");
                }
            }
        }