static XElement BuildMembers(MemberTypeSection section, TypeDom type)
{
switch (section)
{
case MemberTypeSection.NestedTypes:
return(BuildNestedTypes(type.NestedTypes));
case MemberTypeSection.Constructors:
return(BuildMembers(Strings.Constructors, type.Constructors));
case MemberTypeSection.Properties:
return(BuildMembers(Strings.Properties, type.Properties));
case MemberTypeSection.Methods:
return(BuildMembers(Strings.Methods, type.Methods));
case MemberTypeSection.ExtentionMethods:
return(BuildMembers(Strings.ExtentionMethods, type.ExtentionMethods, true));
case MemberTypeSection.Operators:
return(BuildMembers(Strings.Operators, type.Operators));
case MemberTypeSection.Fields:
return(BuildMembers(Strings.Fields, type.Fields));
case MemberTypeSection.Events:
return(BuildMembers(Strings.Events, type.Events));
default: throw new Exception();
}
}
static XElement InheritanceSection(TypeDom type)
{
if (type.Type.IsValueType || type.Type.IsEnum || type.Type.IsInterface || type.Type.IsSubclassOf(typeof(Delegate)))
{
return(x("div"));
}
var space = string.Empty;
var content = new XElement("div");
var baseTypes = type.BaseTypes;
var derivedTypes = type.DerivedTypes;
if (baseTypes.Length == 0 && derivedTypes.Length == 0)
{
return(null);
}
foreach (var baseType in baseTypes)
{
content.Add(space, BuildTypeUrl(baseType), x("br"));
space += Nbsp + Nbsp;
}
content.Add(x("b", space + type.GetDisplayName(true)), x("br"));
space += Nbsp + Nbsp;
foreach (var derivedType in derivedTypes)
{
content.Add(space, BuildTypeUrl(derivedType), x("br"));
}
return(Section(Names[Strings.InheritanceHierarchy], content, a("class", "doc_inheritance")));
}
public static void Merge(TypeDom[] allTypes)
{
//словарь типов, в значении список первый элемент которого TypeDom того же типа, следующие элементы - базовые классы
//по мере обработки словаря эти базовые классы если присутствуют в списке, то должны отсутствовать в словаре.
//Т.е. во всех списках словаря, конкретный TypeDom присутствует в одном экземпляре.
Dictionary<Type,List<TypeDom>> dict = allTypes.ToDictionary(_ => _.Type, t => new List<TypeDom> {t});
foreach (var typeDom in allTypes)
{
List<TypeDom> curEntry; // = dict[typeDom.Type];
if(!dict.TryGetValue(typeDom.Type, out curEntry))
continue;
foreach (Type baseType in TypeUtils.GetBaseTypes(typeDom.Type))
{
//Извлечение и удаление из словаря, и добавление извлеченного списка к curEntry
List<TypeDom> baseEntry;
if (dict.TryGetValue(baseType, out baseEntry))
{
dict.Remove(baseType);
curEntry.AddRange(baseEntry);
}
}
}
foreach (List<TypeDom> lst in dict.Values)
{
if (1 < lst.Count)
MergeBaseToDerived(lst.AsEnumerable().Reverse());
}
}
public static void Populate(TypeDom[] allTypes)
{
ILookup<Type, MethodDom> extentionsLookup = GetExtentionMethods(allTypes)
.ToLookup(_ => _.FirtParameterType);
foreach (var typeDom in allTypes)
typeDom.ExtentionMethods =
GetExtentionMethods(typeDom.Type, extentionsLookup)
.OrderBy(_ => _.FirtParameterType.FullName ?? _.FirtParameterType.Name) //Для generic параметра FullName может быть null
.ToArray();
}
private static void AddMembers(OfflineDynamicPage parentNode, TypeDom type, MemberDom[] members, MemberTypeSection section)
{
if (members == null || members.Length == 0)
{
return;
}
var sectionItem = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = parentNode.UrlPart + "/" + section.ToString(),
RussianTitle = GenerateHtml.GetSectionName(section),
RussianContent = GenerateHtml.Generate(new TypePartialData {
SectionType = section, Type = type
}),
};
if (section == MemberTypeSection.Methods || section == MemberTypeSection.ExtentionMethods)
{
GenerateMethods((MethodDom[])members, sectionItem, parentNode.UrlPart);
}
else
{
foreach (var member in members)
{
//ToDo: Группировка переопределенных методов.
var memberItem = new OfflineDynamicPage
{
Parent = sectionItem,
UrlPart = parentNode.UrlPart + "/" + member.SimpleName,
RussianTitle = member.ShortSignature,
RussianContent = GenerateHtml.Generate(member),
};
sectionItem.Childs.Add(memberItem);
}
}
parentNode.Childs.Add(sectionItem);
}
static string Generate(TypeDom type)
{
var doc = GetDoc(out var body);
body.Add(
x("h1", type.GetDisplayName(false) + Names[Strings.SuffixDelimeter] + Names[type.TypeKind.ToString()]),
x("p", XMLUtils.GetTagInnerXml(type.DocInfo, "summary", Navigation, true)),
InheritanceSection(type),
NamespaceAssembly(type.Type),
GenerateSyntax(type),
BuldParameters(Names[Strings.TypeParameters], type.GenericTypeParameters)
);
for (int i = 0; i <= (int)MemberTypeSection.Events; i++)
{
body.Add(BuildMembers((MemberTypeSection)i, type));
}
body.Add(BuildEnding(type.Assembly, type.DocInfo));
return(doc.ToString());
}
public TypePartialData(TypeDom type, MemberTypeSection sectionType)
{
Type = type;
SectionType = sectionType;
}
private static XElement GenerateSyntax(TypeDom type)
{
var parts = new List <XElement>();
foreach (var attr in type.Type.GetAttributes(false).Where(a1 => a1.GetType() != typeof(ExtensionAttribute)))
{
parts.Add(BuildTypeUrl(attr.GetType(), false, true));
parts.Add(x("br"));
}
parts.Add(x("span", type.Type.IsPublic ? "public" : "protected", a("style", "color:Blue;")));
if (type.Type.IsStatic())
{
parts.Add(x("span", "static", a("style", "color:Blue;")));
}
parts.Add(x("span", type.TypeKind.ToString().ToLowerInvariant(), a("style", "color:Blue;")));
parts.Add(x("span", type.Name));
var interfaces = type.Type.GetInterfaces();
if (type.TypeKind == TypeDom.TypeKindEnum.Class)
{
if (type.Type.BaseType != typeof(object) || interfaces.Length > 0)
{
parts.Add(x("span", " : "));
if (type.Type.BaseType != typeof(object))
{
parts.Add(BuildTypeUrl(type.Type.BaseType, false));
if (interfaces.Length > 0)
{
parts.Add(x("span", ","));
}
}
foreach (var itf in interfaces)
{
parts.Add(BuildTypeUrl(itf, false));
parts.Add(x("span", ","));
}
if (interfaces.Length > 0)
{
parts.RemoveAt(parts.Count - 1);
}
}
}
else if (type.TypeKind == TypeDom.TypeKindEnum.Enum)
{
if (type.Type.GetEnumBaseType() != typeof(int))
{
parts.Add(x("span", " : "));
parts.Add(BuildTypeUrl(type.Type.BaseType, false));
}
}
else if (type.TypeKind == TypeDom.TypeKindEnum.Interface || type.TypeKind == TypeDom.TypeKindEnum.Struct)
{
if (interfaces.Length > 0)
{
parts.Add(x("span", " : "));
foreach (var itf in interfaces)
{
parts.Add(BuildTypeUrl(itf, false));
parts.Add(x("span", ","));
}
if (interfaces.Length > 0)
{
parts.RemoveAt(parts.Count - 1);
}
}
}
return(x("div", a("class", "doc_syntax"), x("code", parts)));
}
