private MethodDoc ParseMethod(Type type, MethodInfo method, XmlDocTree xmlDocTree)
{
MethodDoc methodDoc = new MethodDoc()
{
Name = method.Name,
ReturnType = method.ReturnType,
IsStatic = method.IsStatic,
IsAbstract = method.IsAbstract,
InheritedFrom = method.DeclaringType == type ? null : method.DeclaringType,
Obsolete = method.IsDefined(typeof(ObsoleteAttribute), true),
ObsoleteString = method.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
};
DocMember member = xmlDocTree.GetDocumentation(method);
if (member != null)
{
methodDoc.Summary = member.Summary;
methodDoc.ReturnSummary = member.ReturnsSummary;
}
methodDoc.Parameters = ParseParameters(method, member);
return(methodDoc);
}
private void ParseClass(Type type, XmlDocTree xmlDocTree)
{
ClassTypeDoc classType = new ClassTypeDoc()
{
Name = type.Name,
Type = type,
Namespace = type.Namespace,
IsGeneric = type.IsGenericType,
IsStatic = type.IsAbstract && type.IsSealed,
IsAbstract = type.IsAbstract,
IsSealed = type.IsSealed,
Obsolete = type.IsDefined(typeof(ObsoleteAttribute), true),
ObsoleteString = type.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
};
foreach (MethodInfo method in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static).Where(x => !x.IsSpecialName))
{
classType.Methods.Add(ParseMethod(type, method, xmlDocTree));
}
foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
{
classType.Fields.Add(ParseField(type, field, xmlDocTree));
}
foreach (PropertyInfo property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
{
classType.Properties.Add(ParseProperty(type, property, xmlDocTree));
}
foreach (ConstructorInfo constructor in type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
{
classType.Constructors.Add(ParseConstructor(type, constructor, xmlDocTree));
}
DocMember member = xmlDocTree.GetDocumentation(type);
if (member != null)
{
classType.Summary = member.Summary;
}
docTypes.Add(classType);
}
static void Main(string[] args)
{
if (args.Length < 4)
{
return;
}
string inputDll = Path.GetFullPath(args[0]);
string inputXml = Path.GetFullPath(args[1]);
string outputYaml = Path.GetFullPath(args[2]);
string outputFolder = Path.GetFullPath(args[3]);
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
else
{
Directory.GetFiles(outputFolder).ToList().ForEach(x =>
{
if (Path.GetFileNameWithoutExtension(x).ToLower() != "index")
{
File.Delete(Path.Combine(outputFolder, x));
}
});
}
Assembly assembly = Assembly.UnsafeLoadFrom(inputDll);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(inputXml);
Console.WriteLine("Parsing XmlDocs");
XmlDocTree xmlDocTree = XmlDocTree.Parse(xmlDocument);
Console.WriteLine("Parsing DocTree");
DocTree docTree = DocTree.Parse(assembly, xmlDocTree);
Console.WriteLine("Printing DocTree");
Printer.Print(docTree, outputYaml, outputFolder);
}
private FieldDoc ParseField(Type type, FieldInfo field, XmlDocTree xmlDocTree)
{
FieldDoc fieldDoc = new FieldDoc()
{
Name = field.Name,
Type = field.FieldType,
InheritedFrom = field.DeclaringType == type ? null : field.DeclaringType,
IsStatic = field.IsStatic,
Obsolete = field.IsDefined(typeof(ObsoleteAttribute), true),
ObsoleteString = field.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
};
DocMember member = xmlDocTree.GetDocumentation(field);
if (member != null)
{
fieldDoc.Summary = member.Summary;
}
return(fieldDoc);
}
public static DocTree Parse(Assembly assembly, XmlDocTree xmlDocTree)
{
DocTree docTree = new DocTree();
foreach (Type type in assembly.ExportedTypes)
{
if (type.IsEnum)
{
docTree.ParseEnum(type, xmlDocTree);
}
else if (type.IsClass)
{
docTree.ParseClass(type, xmlDocTree);
}
else if (type.IsValueType)
{
docTree.ParseStruct(type, xmlDocTree);
}
}
return(docTree);
}
private PropertyDoc ParseProperty(Type type, PropertyInfo property, XmlDocTree xmlDocTree)
{
PropertyDoc propertyDoc = new PropertyDoc()
{
Name = property.Name,
Type = property.PropertyType,
Getter = property.CanRead,
Setter = property.CanWrite,
InheritedFrom = property.DeclaringType == type ? null : property.DeclaringType,
Obsolete = property.IsDefined(typeof(ObsoleteAttribute), true),
ObsoleteString = property.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
};
DocMember member = xmlDocTree.GetDocumentation(property);
if (member != null)
{
propertyDoc.Summary = member.Summary;
}
return(propertyDoc);
}
private void ParseEnum(Type type, XmlDocTree xmlDocTree)
{
EnumTypeDoc enumType = new EnumTypeDoc()
{
Name = type.Name,
Type = type,
Namespace = type.Namespace
};
foreach (string name in type.GetEnumNames())
{
EnumDoc enumValue = new EnumDoc()
{
Name = name
};
DocMember member = xmlDocTree.GetDocumentationEnumValue(type, name);
if (member != null)
{
enumValue.Summary = member.Summary;
}
enumType.Values.Add(enumValue);
}
{
DocMember member = xmlDocTree.GetDocumentation(type);
if (member != null)
{
enumType.Summary = member.Summary;
}
}
docTypes.Add(enumType);
}
private ConstructorDoc ParseConstructor(Type type, ConstructorInfo constructor, XmlDocTree xmlDocTree)
{
ConstructorDoc constructorDoc = new ConstructorDoc()
{
Type = type,
Obsolete = constructor.IsDefined(typeof(ObsoleteAttribute), true),
ObsoleteString = constructor.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
};
DocMember member = xmlDocTree.GetDocumentation(constructor);
if (member != null)
{
constructorDoc.Summary = member.Summary;
}
constructorDoc.Parameters = ParseParameters(constructor, member);
return(constructorDoc);
}
public static XmlDocTree Parse(XmlDocument document)
{
XmlDocTree xmlTree = new XmlDocTree();
XmlNode memberNodes = document.SelectSingleNode(".//members");
if (memberNodes != null)
{
foreach (XmlNode memberNode in memberNodes)
{
if (memberNode.Attributes == null)
{
continue;
}
DocMember member = new DocMember();
XmlNode summaryNode = memberNode.SelectSingleNode(".//summary");
if (summaryNode != null)
{
member.Summary = summaryNode.InnerText.Trim();
}
XmlNode returnsNode = memberNode.SelectSingleNode(".//returns");
if (returnsNode != null)
{
member.ReturnsSummary = returnsNode.InnerText.Trim();
}
XmlNodeList paramNodes = memberNode.SelectNodes(".//param");
if (paramNodes != null)
{
foreach (XmlNode parameterNode in paramNodes)
{
if (parameterNode.Attributes == null)
{
continue;
}
member.Parameters.Add(parameterNode.Attributes["name"].Value, parameterNode.InnerText.Trim());
}
}
XmlNode typeParamNodes = memberNode.SelectSingleNode(".//typeparam");
if (typeParamNodes != null)
{
foreach (XmlNode typeParamNode in typeParamNodes)
{
if (typeParamNode.Attributes == null)
{
continue;
}
member.TypeParams.Add(typeParamNode.Attributes["name"].Value, typeParamNode.InnerText.Trim());
}
}
xmlTree.documentation.Add(memberNode.Attributes["name"].Value, member);
}
}
return(xmlTree);
}
