private static async Task Constructors(StreamWriter writer, Type type, XDocument xmlComments)
{
var constructors = type.GetConstructors();
if (constructors.Length > 0)
{
await writer.WriteLineAsync("### Constructors");
await writer.WriteLineAsync("| | |");
await writer.WriteLineAsync("|_|_|");
foreach (var constructor in constructors)
{
await writer.WriteAsync("[");
await TypeHelper.FullName(writer, type, t => t.Name, "<", ">");
await writer.WriteAsync("(");
var parameters = constructor.GetParameters();
if (parameters.Length > 0)
{
await TypeHelper.FullName(writer, parameters[0].ParameterType, t => t.Name, "<", ">");
for (var i = 1; i < parameters.Length; i++)
{
await writer.WriteAsync(", ");
await TypeHelper.FullName(writer, parameters[i].ParameterType, t => t.Name, "<", ">");
}
}
await writer.WriteAsync(")](");
await writer.WriteAsync(FileNameHelper.ConstructorFileName(string.Empty, type));
await writer.WriteAsync(")|");
await writer.WriteLineAsync(
XmlCommentHelper.Summary(XmlCommentHelper.MethodElement(xmlComments, constructor)));
}
}
}
internal static async Task Build(Assembly assembly, XDocument xmlComments, string outputPath)
{
var exportedTypesByNamespace = DocumentBuilder.ExportedTypesByNamespace(assembly);
foreach ((var typeNamespace, var types) in exportedTypesByNamespace)
{
foreach (var type in types)
{
if (!TypeHelper.TypeIsADelegate(type))
{
var constructors = type
.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(o => o.IsPublic || o.IsFamily)
.ToList();
if (constructors.Count > 0)
{
await using (var writer = File.CreateText(
FileNameHelper.ConstructorFileName(outputPath, type)))
{
if (constructors.Count > 1)
{
await ConstructorDocument.BuildMultiple(writer, type, constructors, xmlComments);
}
else
{
await ConstructorDocument.BuildSingle(writer, type, constructors[0], xmlComments);
}
}
}
foreach (var property in type.GetProperties().Where(o => o.DeclaringType == type))
{
await using (var writer =
File.CreateText(FileNameHelper.PropertyFileName(outputPath, property)))
{
await PropertyDocument.Build(writer, property, xmlComments);
}
}
foreach (var methods in type
.GetMethods(
BindingFlags.Instance |
BindingFlags.Static |
BindingFlags.Public |
BindingFlags.NonPublic)
.Where(
o => o.DeclaringType == type &&
!o.IsSpecialName &&
(o.IsPublic || o.IsFamily) &&
(!o.IsVirtual || (o.Attributes & MethodAttributes.NewSlot) != 0))
.GroupBy(o => o.Name)
.Select(o => o.ToList()))
{
await using (var writer =
File.CreateText(FileNameHelper.MethodFileName(outputPath, methods[0])))
{
if (methods.Count > 1)
{
await MethodDocument.BuildMultiple(writer, assembly, type, methods, xmlComments);
}
else
{
await MethodDocument.BuildSingle(writer, assembly, type, methods[0], xmlComments);
}
}
}
}
await using (var writer = File.CreateText(FileNameHelper.TypeFileName(outputPath, type)))
{
if (TypeHelper.TypeIsADelegate(type))
{
await DelegateDocument.Build(writer, type, xmlComments);
}
else
{
await TypeDocument.Build(writer, type, xmlComments);
}
}
}
await using (var writer = File.CreateText(FileNameHelper.NamespaceFileName(outputPath, typeNamespace)))
{
await NamespaceDocument.Build(writer, typeNamespace, types, xmlComments);
}
}
if (exportedTypesByNamespace.Count > 1)
{
await using (var writer =
File.CreateText(FileNameHelper.AssemblyFileName(outputPath, assembly.GetName())))
{
await AssemblyDocument.Build(
writer,
assembly,
exportedTypesByNamespace.Select(o => o.TypeNamespace));
}
}
}