Ejemplo n.º 1
0
        private static void AppendMarkdown(StringBuilder sb, CodeInfo cinfo, Assembly asm)
        {
            Console.WriteLine("Generating C# documentation.");

            Type astro = asm.GetType("CosineKitty.Astronomy");

            // Document all public constants in the Astronomy class.
            FieldInfo[] constants = astro.GetFields(BindingFlags.Public | BindingFlags.Static)
                                    .Where(f => f.IsLiteral && !f.IsInitOnly)
                                    .OrderBy(f => f.Name.ToUpperInvariant())
                                    .ToArray();

            AppendSectionHeader(sb, "Constants");
            foreach (FieldInfo c in constants)
            {
                AppendConstantMarkdown(sb, cinfo, c);
            }

            // All the member functions in the Astronomy class go in the "functions" section.

            AppendSectionHeader(sb, "Functions");
            MethodInfo[] funcs = astro.GetMethods()
                                 .Where(m => m.IsPublic && m.IsStatic)
                                 .OrderBy(m => m.Name.ToUpperInvariant())
                                 .ToArray();

            foreach (MethodInfo f in funcs)
            {
                AppendFunctionMarkdown(sb, cinfo, f);
            }

            // The classes other than "Astronomy" are listed one by one in the "classes" section.
            sb.AppendLine("---");
            sb.AppendLine();
            AppendSectionHeader(sb, "Types");
            Type[] typeList = asm.GetExportedTypes()
                              .Where(c => c.Name != "Astronomy")
                              .OrderBy(c => c.Name.ToUpperInvariant())
                              .ToArray();

            foreach (Type c in typeList)
            {
                AppendTypeMarkdown(sb, cinfo, c);
            }
        }
Ejemplo n.º 2
0
        private static void AppendConstantMarkdown(StringBuilder sb, CodeInfo cinfo, FieldInfo f)
        {
            CodeItem item = cinfo.FindField(f);

            if (item == null)
            {
                return;
            }

            string fieldType;

            switch (f.FieldType.Name)
            {
            case "Double":
                fieldType = "double";
                break;

            default:
                throw new Exception($"Do not know how to generate markdown for constant type: {f.FieldType.Name}");
            }

            string parentClassName = f.DeclaringType.Name;

            sb.AppendFormat("<a name=\"{0}.{1}\"></a>", parentClassName, f.Name);
            sb.AppendLine();
            sb.AppendFormat("### `const {0} {1}.{2} = {3};`", fieldType, parentClassName, f.Name, f.GetValue(null));
            sb.AppendLine();
            sb.AppendLine();
            if (!string.IsNullOrWhiteSpace(item.Summary))
            {
                sb.AppendLine("**" + item.Summary + "**");
                sb.AppendLine();
            }

            if (!string.IsNullOrWhiteSpace(item.Remarks))
            {
                sb.AppendLine(item.Remarks);
                sb.AppendLine();
            }
            sb.AppendLine();
            sb.AppendLine("---");
            sb.AppendLine();
        }
Ejemplo n.º 3
0
        private static void AppendTypeMarkdown(StringBuilder sb, CodeInfo cinfo, Type type)
        {
            string kind;

            if (type.IsClass)
            {
                kind = "class";
            }
            else if (type.IsEnum)
            {
                kind = "enum";
            }
            else
            {
                kind = "struct";
            }

            CodeItem typeItem = cinfo.FindType(type);

            // Header

            sb.AppendLine("<a name=\"" + type.Name + "\"></a>");
            sb.AppendLine("## `" + kind + " " + type.Name + "`");
            sb.AppendLine();

            if (!string.IsNullOrWhiteSpace(typeItem.Summary))
            {
                sb.AppendLine("**" + typeItem.Summary + "**");
                sb.AppendLine();
            }

            if (!string.IsNullOrWhiteSpace(typeItem.Remarks))
            {
                sb.AppendLine(typeItem.Remarks);
                sb.AppendLine();
            }

            if (type.IsEnum)
            {
                // Dump enum values.
                FieldInfo[] fields = type.GetFields().Where(f => f.IsLiteral).ToArray();
                if (fields.Length > 0)
                {
                    sb.AppendLine("| Value | Description |");
                    sb.AppendLine("| --- | --- |");
                    foreach (FieldInfo f in fields)
                    {
                        AppendEnumValueMarkdown(sb, cinfo, f);
                    }
                    sb.AppendLine();
                }
            }
            else
            {
                // Dump struct/class fields.
                FieldInfo[] fields = type.GetFields();
                if (fields.Length > 0)
                {
                    sb.AppendLine("| Type | Name | Description |");
                    sb.AppendLine("| --- | --- | --- |");
                    foreach (FieldInfo f in fields)
                    {
                        if (f.DeclaringType == type)
                        {
                            AppendMemberVariableMarkdown(sb, cinfo, f);
                        }
                    }
                    sb.AppendLine();
                }
            }

            // Member functions

            MethodInfo[] funcs = type.GetMethods()
                                 .Where(m => m.IsPublic && m.DeclaringType == type)
                                 .OrderBy(m => m.Name.ToUpperInvariant())
                                 .ToArray();

            if (funcs.Length > 0)
            {
                sb.AppendLine("### member functions");
                sb.AppendLine();

                foreach (MethodInfo f in funcs)
                {
                    AppendFunctionMarkdown(sb, cinfo, f);
                }
            }

            sb.AppendLine("---");
            sb.AppendLine();
        }