/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="type">The type information.</param>
/// <param name="commentLookup">The XML comment of the type and the members.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public TypeWithComment(Type type, ILookup <string, XmlComment>?commentLookup, ClassDocContext context)
{
Context = context;
m_CommentLookup = commentLookup;
this.Info = type;
GenericParameterTypes = CreateGenericParameters().AsReadOnly();
Constructors = CreateConstructors().AsReadOnly();
Methods = CreateMethodList().AsReadOnly();
Properties = CreatePropertyList().AsReadOnly();
Fields = CreateFieldList().AsReadOnly();
Events = CreateEventList().AsReadOnly();
if (commentLookup == null)
{
Comment = XmlComment.Empty;
}
else
{
string typeName = type.FullName.Replace('+', '.');
Comment = commentLookup[typeName].Where(x => x.Kind == XmlCommentKind.Type && x.TypeName == typeName).FirstOrDefault() ?? XmlComment.Empty;
}
DelegateMethodInfo = CreateDelegateMethodInfo();
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="member">The member information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
protected MemberInfoWithComment(TInfo member, XmlComment comment, ClassDocContext context)
{
Context = context;
Info = member;
Comment = comment ?? XmlComment.Empty;
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="parameter">The parameter information.</param>
/// <param name="commentGetter">The method to get comment of parameter.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public ParameterInfoWithComment(ParameterInfo parameter, Func <ParameterComment> commentGetter, ClassDocContext context)
{
m_Context = context;
Info = parameter;
m_CommentGetter = commentGetter;
}
/// <summary>
/// Loads the types defined in the specified assembly.
/// </summary>
/// <param name="dllPath">The assembly file path.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
/// <param name="nameSpace">The namespace to load.</param>
/// <returns>The type information.</returns>
private static IEnumerable <TypeWithComment> EnumerateTypes(string dllPath, ClassDocContext context, string?nameSpace = null)
{
var xmlPath = Path.Combine(Directory.GetParent(dllPath).FullName, Path.GetFileNameWithoutExtension(dllPath) + ".xml");
IEnumerable <XmlComment> comments = new XmlComment[0];
if (File.Exists(xmlPath))
{
comments = XmlCommentReader.ReadXmlComments(XDocument.Parse(File.ReadAllText(xmlPath)), context, nameSpace);
}
var commentsLookup = comments.ToLookup(x => x.TypeName);
// List<TypeWithComment> typeComments = new List<TypeWithComment>();
Func <Type, bool> typeFilter;
if (!string.IsNullOrEmpty(nameSpace))
{
typeFilter = type =>
{
if (!type.Namespace.StartsWith(nameSpace))
{
return(false);
}
if (context.TypeFilter != null && !context.TypeFilter(type))
{
return(false);
}
return(true);
};
}
else
{
typeFilter = context.TypeFilter;
}
foreach (var type in EnumerateTypes(Assembly.LoadFrom(dllPath), typeFilter))
{
var info = new TypeWithComment(type, commentsLookup, context);
// typeComments.Add(info);
context.StoreTypeInfo(info);
yield return(info);
}
// return typeComments.AsReadOnly();
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="exceptionTypeSignature">The exception type signature.</param>
/// <param name="descriptions">The descriptions.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public ExceptionComment(string exceptionTypeSignature, string[] descriptions, ClassDocContext context)
{
Context = context;
ExceptionTypeSignatureName = exceptionTypeSignature;
Descriptions = descriptions;
m_ExceptionType = null;
if (XmlCommentSignature.TryParse(exceptionTypeSignature, out var signature))
{
if (TypeLoader.TryGetType(signature.TypeName, out Type? type))
{
m_ExceptionType = type;
}
}
ExceptionTypeSignature = signature;
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="prop">The property information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public PropertyInfoWithComment(PropertyInfo prop, XmlComment comment, ClassDocContext context) : base(prop, comment, context)
{
Parameters = CreateParameterList(Info.GetIndexParameters());
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public XmlComment(ClassDocContext context)
{
Context = context;
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="method">The method information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public MethodInfoWithComment(MethodInfo method, XmlComment comment, ClassDocContext context) : base(method, comment, context)
{
Parameters = CreateParameterList(method.GetParameters());
GenericParameterTypes = CreateGenericParameters().AsReadOnly();
}
internal ParameterComment(string name, ClassDocContext context)
{
Context = context;
Name = name;
Descriptions = EmptyStringArray;
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="name">The parameter name.</param>
/// <param name="descriptions">The descriptions.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public ParameterComment(string name, string[] descriptions, ClassDocContext context)
{
Context = context;
Name = name;
Descriptions = descriptions ?? EmptyStringArray;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="ctor">The constructor information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public ConstructorInfoWithComment(ConstructorInfo ctor, XmlComment comment, ClassDocContext context) : base(ctor, comment, context)
{
Parameters = CreateParameterList(ctor.GetParameters());
}
/// <summary>
/// Reads XML comments from the specified XML document.
/// </summary>
/// <param name="xDocument">The XML document.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
/// <param name="nameSpace">The namespace to read.</param>
/// <returns>An Enumerator.</returns>
internal static IEnumerable <XmlComment> ReadXmlComments(XDocument xDocument, ClassDocContext context, string?nameSpace = null)
{
string assemblyName = xDocument.Descendants("assembly").First().Elements("name").First().Value;
IEnumerable <XmlComment?> documents = xDocument.Descendants("member")
.Select(x =>
{
// signature
string signatureName = x.Attribute("name").Value;
if (!XmlCommentSignature.TryParse(signatureName, out XmlCommentSignature signature))
{
return(null);
}
string summary = FormatTextElement(x.Elements("summary"));
string returns = FormatTextElement(x.Elements("returns"));
string remarks = FormatTextElement(x.Elements("remarks"));
// paeameter
var parameters = x.Elements("param")
.Select(element => (name: element.Attribute("name").Value, content: FormatTextElement(element)))
.GroupBy(comment => comment.name)
.ToDictionary(group => group.Key, g => new ParameterComment(g.Key, g.Select(v => v.content).ToArray(), context))
;
// type parameter
var typeParameters = x.Elements("typeparam")
.Select(element => (name: element.Attribute("name").Value, content: FormatTextElement(element)))
.GroupBy(comment => comment.name)
.ToDictionary(group => group.Key, g => new ParameterComment(g.Key, g.Select(v => v.content).ToArray(), context))
;
// exception
var exceptions = x.Elements("exception")
.Select(e => (name: e.Attribute("cref").Value, content: FormatTextElement(e)))
.GroupBy(comment => comment.name)
.ToDictionary(group => group.Key, g => new ExceptionComment(g.Key, g.Select(v => v.content).ToArray(), context))
.Values.ToArray();
// inheritdoc
bool inheritdoc = x.Element("inheritdoc") != null;
return(new XmlComment(context)
{
SignatureName = signatureName,
IsInherit = inheritdoc,
Signature = signature,
Summary = summary.Trim(),
Remarks = remarks.Trim(),
ParametersInternal = parameters,
TypeParametersInternal = typeParameters,
Returns = returns.Trim(),
ExceptionsInternal = exceptions,
});
});
foreach (var doc in documents)
{
if (doc == null)
{
continue;
}
if (!string.IsNullOrWhiteSpace(nameSpace) && !doc.TypeName.StartsWith(nameSpace))
{
continue;
}
// System.Diagnostics.Debug.WriteLine(doc.SignatureName);
yield return(doc);
}
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="field">The field information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public FieldInfoWithComment(FieldInfo field, XmlComment comment, ClassDocContext context) : base(field, comment, context)
{
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="evt">The field information.</param>
/// <param name="comment">The XML comment.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public EventInfoWithComment(EventInfo evt, XmlComment comment, ClassDocContext context) : base(evt, comment, context)
{
}
/// <summary>
/// Loads the types defined in the specified assemblies.
/// </summary>
/// <param name="dllPaths">The assembly file path.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
/// <param name="nameSpace">The namespace to load.</param>
/// <returns>The type information.</returns>
public static IReadOnlyList <TypeWithComment> LoadTypes(IEnumerable <string> dllPaths, ClassDocContext context, string?nameSpace = null)
{
List <TypeWithComment> types = new List <TypeWithComment>();
foreach (var dllPath in dllPaths)
{
foreach (var type in EnumerateTypes(dllPath, context, nameSpace))
{
types.Add(type);
}
}
return(types.AsReadOnly());
}
/// <summary>
/// Loads the types defined in the specified assembly.
/// </summary>
/// <param name="dllPath">The assembly file path.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
/// <param name="nameSpace">The namespace to load.</param>
/// <returns>The type information.</returns>
public static IReadOnlyList <TypeWithComment> LoadTypes(string dllPath, ClassDocContext context, string?nameSpace = null)
{
return(EnumerateTypes(dllPath, context, nameSpace).ToArray());
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="parameterType">The generic parameter type.</param>
/// <param name="commentGetter">The method to get comment of parameter.</param>
/// <param name="context">The context that manages the state of the output process for class documents.</param>
public TypeParameterWithComment(Type parameterType, Func <ParameterComment> commentGetter, ClassDocContext context)
{
ParameterType = parameterType;
Context = context;
m_CommentGetter = commentGetter;
}
