/// <summary>
/// Processes the public constructor overloads.
/// </summary>
/// <param name="exportedType">The <see cref="DocExportedType"/>.</param>
private void ProcessConstructors(DocExportedType exportedType)
{
if (!exportedType.IsClass)
{
return;
}
exportedType.Constructor = new DocConstructor(exportedType)
{
Name = exportedType.Name,
};
var ctors = exportedType.Type.GetConstructors().Concat(
exportedType.Type.GetConstructors(BindingFlags.Static | BindingFlags.NonPublic)).Distinct()
.OrderBy(c => c.IsStatic ? 1 : 0).ThenBy(c => c.GetParameters().Length);
foreach (var ctor in ctors)
{
var overload = new DocOverload(ctor, exportedType.Constructor)
{
Name = MemberUtils.GenerateCodeFor(ctor),
XPath = MemberUtils.GetSelector(ctor),
};
LinkCache.Register(overload);
var staticText = ctor.IsStatic ? " static " : " ";
overload.Code = $"public{staticText}{overload.Name}";
ProcessParameters(ctor.GetParameters(), overload, overload.Parameters);
exportedType.Constructor.Overloads.Add(overload);
}
}
/// <summary>
/// Iterate the types for the namespace.
/// </summary>
/// <param name="docNamespace">The <see cref="DocNamespace"/> to parse into.</param>
private void IterateTypes(DocNamespace docNamespace)
{
foreach (var type in Types.Where(t => t.Namespace == docNamespace.Name))
{
Console.WriteLine($"Parsing type \"{type.FullName}\"...");
var exportedType = new DocExportedType
{
Namespace = docNamespace,
};
ProcessType(type, exportedType);
docNamespace.Types.Add(exportedType);
}
}
/// <summary>
/// Parses a <see cref="DocExportedType"/> to a <see cref="DocFile"/>.
/// </summary>
/// <param name="t">The <see cref="DocExportedType"/> to parse.</param>
/// <returns>The transformed <see cref="DocFile"/>.</returns>
private DocFile ProcessType(DocExportedType t)
{
var result = new DocFile(t.FileName);
var classification = t.IsInterface ? "Interface" : (t.IsEnum ? "Enum" : "Class");
result.AddThenBlankLine(writer.WriteHeading1($"{MarkdownWriter.Normalize(t.TypeRef.FriendlyName)} {classification}"));
result.AddThenBlankLine(ParserUtils.ProcessBreadcrumb(t));
result.AddThenBlankLine(t.Description);
ExtractCode(t.Code, result);
ExtractTypeParameters(t.TypeParameters, result);
if (t.Inheritance.Any())
{
result.AddThenBlankLine(ParserUtils.ParseInheritance(t.Inheritance));
}
if (t.ImplementedInterfaces.Any())
{
result.AddThenBlankLine(ParserUtils
.ParseImplementedInterfaces(t.ImplementedInterfaces));
}
if (t.DerivedTypes.Any())
{
result.AddThenBlankLine(ParserUtils
.ParseDerivedTypes(t.DerivedTypes));
}
ExtractExamples(t.Example, result);
ExtractRemarks(t.Remarks, result);
ExtractCtors(t.Constructor, result);
ExtractProperties(t.Properties, result);
ExtractMethods(t, result);
return(result);
}
/// <summary>
/// Processes the public method overloads.
/// </summary>
/// <param name="exportedType">The <see cref="DocExportedType"/>.</param>
private void ProcessMethods(DocExportedType exportedType)
{
var typePropertyMethods = exportedType.Type.GetProperties()
.Select(p => new[] { p.GetMethod, p.SetMethod })
.SelectMany(p => p)
.Where(p => p != null)
.Distinct();
var typeMethods = exportedType.Type.GetMethods(
BindingFlags.Public |
BindingFlags.Static |
BindingFlags.Instance).Where(m => m.DeclaringType == exportedType.Type)
.Except(typePropertyMethods);
foreach (var methodInfo in typeMethods)
{
var method = exportedType.Methods.FirstOrDefault(m => m.Name == methodInfo.Name);
if (method == null)
{
method = new DocMethod(exportedType)
{
Name = methodInfo.Name,
MethodReturnType = TypeCache.Cache[methodInfo.ReturnType],
};
exportedType.Methods.Add(method);
}
var methodOverload = new DocMethodOverload(methodInfo, method)
{
Name = MemberUtils.GenerateCodeFor(methodInfo),
XPath = MemberUtils.GetSelector(methodInfo),
};
LinkCache.Register(methodOverload);
methodOverload.Code = methodOverload.Name;
ProcessParameters(methodInfo.GetParameters(), methodOverload, methodOverload.Parameters);
method.MethodOverloads.Add(methodOverload);
}
}
/// <summary>
/// Process property information.
/// </summary>
/// <param name="exportedType">The <see cref="DocExportedType"/> to parse.</param>
private void ProcessProperties(DocExportedType exportedType)
{
var defaultRules = typeof(DefaultComparisonRules);
foreach (var prop in exportedType.Type.GetProperties(
BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
{
if (prop.DeclaringType != exportedType.Type)
{
continue;
}
var property = new DocProperty(exportedType)
{
Name = $"{exportedType.Name}.{prop.Name}",
XPath = MemberUtils.GetSelector(prop),
Type = prop.PropertyType,
TypeParameters = ProcessTypeParameters(prop.PropertyType),
Code = MemberUtils.GenerateCodeFor(prop),
};
if (exportedType.Type == defaultRules && prop.GetMethod.IsStatic)
{
var expression = prop.GetMethod.Invoke(null, null);
property.CustomInfo = expression.ToString();
}
LinkCache.Register(property);
if (prop.GetIndexParameters().Length > 0)
{
property.IsIndexer = true;
property.IndexerType = TypeCache.Cache[prop.GetIndexParameters().First().ParameterType];
}
property.TypeParameter = exportedType.TypeParameters.FirstOrDefault(
t => t.Name == property.Type.Name);
exportedType.Properties.Add(property);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DocProperty"/> class with a
/// <see cref="DocExportedType"/>.
/// </summary>
/// <param name="parent">The parent <see cref="DocExportedType"/>.</param>
public DocProperty(DocExportedType parent)
{
ParentType = parent;
}
