public override void Write(DocumentFormatter output, OutputContext context)
{
if (Overloads.Count == 0)
{
base.Write(output, context);
return;
}
output.Header(1, SharedTitle);
WriteInfoBox(output, context);
WriteOverloadsSummary(output, context);
output.Table(new[] { "Overload", "Description" }, Overloads,
overload => overload.WriteLink(output, context),
overload => overload.WriteSummaryLine(output, context)
);
foreach (var overload in Overloads)
{
output.Header(2, overload.Name);
overload.WriteSummary(output, context);
var syntax = overload.GetSyntax(context.Language);
if (!string.IsNullOrEmpty(syntax))
{
output.Header(3, "Syntax");
output.Code(syntax, context.Language.Name);
}
overload.WriteDetails(3, output, context);
}
}
public override void Write(DocumentFormatter output, OutputContext context)
{
output.Header(1, Title);
WriteInfoBox(output, context);
WriteSummary(output, context);
var syntax = GetSyntax(context.Language);
if (!string.IsNullOrEmpty(syntax))
{
output.Header(2, "Syntax");
output.Code(syntax, context.Language.Name);
}
WriteDetails(2, output, context);
}
public virtual void WriteParametersSection(int level, DocumentFormatter output, OutputContext context, IEnumerable <ParameterInfo> parameters)
{
if (parameters == null || !parameters.Any())
{
return;
}
var doc = context.Document.Of(this);
output.Header(level, "Parameters");
output.DefinitionList(parameters,
parameter =>
{
output.Text(parameter.Name, TextStyles.Teletype);
output.Text(": ");
if (parameter.ParameterType.IsGenericParameter)
{
output.Text(parameter.ParameterType.GetDisplayName(), TextStyles.Emphasize);
}
else
{
output.LinkCRef(parameter.ParameterType.GetCRef(), parameter.ParameterType.GetDisplayName());
}
},
parameter => output.Section(() => doc?.Parameters.For(parameter.Name, output.Xml, name => Log.WarnMisisngParameterDoc(this, name))));
}
protected virtual void WriteThreadSafetySection(int level, DocumentFormatter output, IEnumerable <XmlThreadSafety> threadSafeties)
{
var threadSafety = threadSafeties?.FirstOrDefault();
if (threadSafety == null)
{
return;
}
output.Header(level, "Thread Safety");
if (threadSafety.Static && threadSafety.Instance)
{
output.Section("Any public member of this type, either static or instance, is thread-safe.");
}
else if (threadSafety.Static && !threadSafety.Instance)
{
output.Section("Any public static member of this type is thread-safe, but instance members are not guaranteed to be thread-safe.");
}
else if (!threadSafety.Static && threadSafety.Instance)
{
output.Section("Any public static member of this type is not guaranteed to be thread-safe, but instance members are thread-safe.");
}
else
{
output.Section("Neither public nor instance members of this type are guaranteed to be thread-safe.");
}
}
protected void WriteTypesInCategory(DocumentFormatter output, OutputContext context, TypeCategory category, IEnumerable <ClrType> types)
{
output.Header(3, category.ToPluralString());
output.Table(new[] { category.ToString(), "Description" }, types,
type => type.WriteLink(output, context),
type => type.WriteSummaryLine(output, context)
);
}
protected void WriteMembersInCategory(int level, DocumentFormatter output, OutputContext context, MemberCategory category, IEnumerable <ClrMember> members)
{
output.Header(level, category.ToPluralString());
output.Table(new[] { category.ToString(), "Description" }, members,
member => member.WriteLink(output, context),
member => member.WriteSummaryLine(output, context)
);
}
public override void WriteMembers(int level, DocumentFormatter output, OutputContext context)
{
output.Header(level, "Members");
output.Table(new[] { "Name", "Value", "Description" }, Info.GetEnumValues().Cast <Enum>(),
value => output.Text(Info.GetEnumName(value)),
value => output.Text((value as IFormattable)?.ToString("D", CultureInfo.InvariantCulture)),
value => context.Document.Members.For(value.GetCRef(), doc => output.Xml(doc.Summaries.FirstOrDefault()))
);
}
public override void Write(DocumentFormatter output, OutputContext context)
{
output.Header(2, Title);
WriteSummaryLine(output, context);
foreach (var typeCategory in TypeCategories.OrderBy(group => group.Key))
{
WriteTypesInCategory(output, context, typeCategory.Key, typeCategory);
typeCategory.ForEach(context.Compose);
}
}
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <XmlNode> items)
{
if (items == null || !items.Any())
{
return;
}
if (!string.IsNullOrEmpty(header))
{
output.Header(level, header);
}
output.Xml(items);
}
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <ICRef> items)
{
if (items == null || !items.Any())
{
return;
}
if (!string.IsNullOrEmpty(header))
{
output.Header(level, header);
}
output.List(items, item => output.LinkCRef(item.CRef, (item as ClrItem)?.Title));
}
protected virtual void WriteSection(DocumentFormatter output, int level, string header, string label, IEnumerable <XmlReferenceNode> items)
{
if (items == null || !items.Any())
{
return;
}
if (!string.IsNullOrEmpty(header))
{
output.Header(level, header);
}
output.Table(new[] { label, "Description" }, items,
item => output.LinkCRef(item.CRef, Utils.FormatCRef(item.CRef)),
item => output.Xml(item));
}
public virtual void WriteTypeParametersSection(int level, DocumentFormatter output, OutputContext context, IEnumerable <Type> typeParameters)
{
if (typeParameters == null || !typeParameters.Any())
{
return;
}
var doc = context.Document.Of(this);
output.Header(level, "Type Parameters");
output.DefinitionList(typeParameters,
typeParameter => output.Text(typeParameter.Name, TextStyles.Teletype),
typeParameter => output.Section(() =>
{
if (WriteTypeParamDoc(doc, typeParameter.Name))
{
return;
}
if (!typeParameter.IsGenericMethodParameter)
{
for (var parent = Owner; parent != null; parent = parent.Owner)
{
if (WriteTypeParamDoc(context.Document.Of(parent), typeParameter.Name))
{
return;
}
}
}
Log.WarnMisisngTypeParameterDoc(this, typeParameter.Name);
}));
bool WriteTypeParamDoc(XmlMember ownerDoc, string paramName)
{
if (ownerDoc != null && ownerDoc.TypeParameters.TryGetValue(paramName, out var paramDoc))
{
output.Xml(paramDoc);
return(true);
}
return(false);
}
}
public virtual void WriteReturnValueSection(int level, DocumentFormatter output, OutputContext context, Type returnType)
{
if (returnType == null || returnType == typeof(void))
{
return;
}
var doc = context.Document.Of(this);
if (doc != null && doc.Returns.Count == 0)
{
Log.WarnMisisngReturnDoc(this);
}
output.Header(level, "Return Value");
output.DefinitionList(new[] { returnType },
type => output.LinkCRef(type.GetCRef(), type.GetDisplayName()),
type => output.Xml(doc?.Returns));
}
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <XmlRevisionHistory> items)
{
var revisions = items?.Where(item => item.IsVisible).SelectMany(item => item.Revisions.Where(revision => revision.IsVisible));
if (revisions == null || !revisions.Any())
{
return;
}
if (!string.IsNullOrEmpty(header))
{
output.Header(level, header);
}
output.Table(new[] { "Date", "Version", "Author", "Description" }, revisions,
revision => output.Text(revision.Date),
revision => output.Text(revision.Version),
revision => output.Text(revision.Author),
revision => output.Xml(revision));
}
public override void Write(DocumentFormatter output, OutputContext context)
{
output.Header(1, Title);
WriteSummaryLine(output, context);
Namespaces.OrderBy(ns => ns.Name).ForEach(ns => ns.Write(output, context));
}
