public void ReadAssembly(string assemblyAbsolutePath, IEnumerable <string> excludedNamespaces)
{
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(assemblyAbsolutePath);
string assemblyName = assembly.Name.Name;
if (assemblyName != name)
{
Logger.Error("Can't load contents of an assembly to another assembly which has different name.");
return;
}
List <TypeDefinition> types = Utils.GetAllTypes(assembly);
foreach (TypeDefinition typeDefinition in types)
{
if (!Utils.ShouldIncludeType(typeDefinition))
{
continue;
}
if (string.IsNullOrEmpty(typeDefinition.Namespace) && typeDefinition.FullName == MyClassInfo.SPECIAL_MODULE_CLASS_NAME)
{
// skip the special <Module> class
continue;
}
MyNamespaceInfo namespaceInfo;
string typeNamespace = Utils.GetTypeNamespace(typeDefinition);
if (excludedNamespaces.Contains(typeNamespace))
{
continue;
}
if (namespaces == null)
{
namespaces = new Dictionary <string, MyNamespaceInfo>();
}
if (!namespaces.ContainsKey(typeNamespace))
{
namespaceInfo = new MyNamespaceInfo(typeNamespace, assemblyName);
namespaces.Add(typeNamespace, namespaceInfo);
}
else
{
namespaceInfo = namespaces[typeNamespace];
}
namespaceInfo.AddType(typeDefinition);
}
}
private void CreateNamespaceMembersIndex(MyNamespaceInfo myNamespaceInfo)
{
string namespaceDirName = GetNamespaceDirName(myNamespaceInfo.Name);
string indexFileName = Utils.CombineMultiplePaths(myNamespaceInfo.AssemblyName + "_" + myNamespaceInfo.AssemblyName.GetHashCode(),
namespaceDirName,
TYPES_INDEX_FILE_NAME);
string filename = Utils.CombineMultiplePaths(outputDirectory, CONTENTS_DIRECTORY, GetAliasName(indexFileName));
FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string pageTitle = String.Format("{0} Namespace", myNamespaceInfo.Name);
string[] sectionsShortcutsNamesAndIndices = ObtainListOfSectionsShortcutsNamesAndIndices(myNamespaceInfo);
string[] sectionsNames = ObtainListOfSectionsNames(myNamespaceInfo);
WriteIndexHeader(sw, pageTitle, sectionsShortcutsNamesAndIndices);
WriteIndexSummary(sw, myNamespaceInfo.Summary);
WriteIndexItemLocation(sw,
null,
null,
myNamespaceInfo.AssemblyName,
null,
null,
ResolveAssemblyLink(myNamespaceInfo.AssemblyName));
int sectionIndex = 0;
int sectionNameIndex = 0;
int namespaceMembersGroupIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupIndex))
{
NamespaceMembersGroups namespaceMembersGroupType = (NamespaceMembersGroups)namespaceMembersGroupIndex;
if (myNamespaceInfo.GetMembersCount(namespaceMembersGroupType) > 0)
{
WriteMembersIndex(sw, sectionsNames[sectionNameIndex++], sectionIndex,
myNamespaceInfo.GetEnumerator(namespaceMembersGroupType),
DEFAULT_MEMBERS_COLUMNS_NAMES,
TYPE_MEMBERS_COLUMNS_WIDTHS,
namespaceMembersGroupType, 0);
}
namespaceMembersGroupIndex++;
sectionIndex++;
}
WriteIndexFooter(sw);
sw.Close();
fs.Close();
}
private void ProcessNamespace(MyNamespaceInfo myNamespaceInfo)
{
CreateNamespaceMembersIndex(myNamespaceInfo);
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups namespaceMembersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
if (myNamespaceInfo.GetMembersCount(namespaceMembersGroupType) > 0)
{
Dictionary<string, MetaClass> namespaceMembers = myNamespaceInfo.GetMembers(namespaceMembersGroupType);
foreach (MetaClass namespaceMember in namespaceMembers.Values)
{
ProcessNamespaceMember(namespaceMember, namespaceMembersGroupType);
}
}
namespaceMembersGroupTypeIndex++;
}
}
private string[] ObtainListOfSectionsNames(MyNamespaceInfo myNamespaceInfo)
{
List<string> result = new List<string>();
int sectionIndex = 0;
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups membersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
if (myNamespaceInfo.GetMembersCount(membersGroupType) > 0)
{
string sectionName = MyNamespaceInfo.NamespaceMembersGroupToString(membersGroupType);
int tmpSectionIndex = sectionIndex;
tmpSectionIndex++;
if (myNamespaceInfo.HasProtectedInternalGroupOfTheSameType(membersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Protected Internal");
}
tmpSectionIndex++;
if (myNamespaceInfo.HasProtectedGroupOfTheSameType(membersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Protected");
}
tmpSectionIndex++;
if (myNamespaceInfo.HasInternalGroupOfTheSameType(membersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Internal");
}
tmpSectionIndex++;
if (myNamespaceInfo.HasPrivateGroupOfTheSameType(membersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Private");
}
result.Add(sectionName);
}
namespaceMembersGroupTypeIndex++;
sectionIndex++;
}
return result.ToArray();
}
private string[] ObtainListOfSectionsShortcutsNamesAndIndices(MyNamespaceInfo myNamespaceInfo)
{
List<string> result = new List<string>();
int sectionIndex = 0;
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups membersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
if (myNamespaceInfo.GetMembersCount(membersGroupType) > 0)
{
if (MyNamespaceInfo.IsMembersGroupTypePublic(membersGroupType))
{
result.Add(MyNamespaceInfo.GetBaseGroupName(membersGroupType) + ":" + sectionIndex);
}
}
namespaceMembersGroupTypeIndex++;
sectionIndex++;
}
return result.ToArray();
}
public MyClassInfo FindNamespaceMember(string xmlMemberId)
{
int indexOfDot = -1;
while (true)
{
string potentialNamespace;
string potentialMemberName;
indexOfDot = xmlMemberId.IndexOf('.', indexOfDot + 1);
if (indexOfDot == -1)
{
potentialNamespace = MyNamespaceInfo.GLOBAL_NAMESPACE_NAME;
}
else
{
potentialNamespace = xmlMemberId.Substring(0, indexOfDot);
}
MyNamespaceInfo myNamespaceInfo = FindNamespace(potentialNamespace);
if (myNamespaceInfo == null)
{
if (indexOfDot == -1)
{
break;
}
else
{
continue;
}
}
if (indexOfDot + 1 < xmlMemberId.Length)
{
potentialMemberName = xmlMemberId.Substring(indexOfDot + 1).Replace('.', '/');
}
else
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
continue;
}
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups namespaceMembersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
MyClassInfo namespaceMember = myNamespaceInfo.FindMember(namespaceMembersGroupType, potentialMemberName);
if (namespaceMember != null)
{
return(namespaceMember);
}
namespaceMembersGroupTypeIndex++;
}
if (indexOfDot == -1)
{
break;
}
}
return(null);
}
private void ProcessMemberNode(XPathNavigator memberNodeNavigator, XPathNavigator docNavigator)
{
string nameAttribValue = memberNodeNavigator.GetAttribute("name", "");
string xmlMemberId = nameAttribValue.Substring(2);
char memberType = nameAttribValue[0];
switch (memberType)
{
case 'T':
{
MyClassInfo myClassInfo = FindNamespaceMember(xmlMemberId);
if (myClassInfo == null)
{
Logger.Warning("(XML) Couldn't locate namespace member '{0}'.", xmlMemberId);
break;
}
myClassInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myClassInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
if (myClassInfo.IsNested)
{
// the class/struct/etc. is a nested typeDefinition
int indexOfLastDot = xmlMemberId.LastIndexOf('.');
Debug.Assert(indexOfLastDot != -1, "There must be dot because this type is nested.");
string declaringTypeFullName = xmlMemberId.Substring(0, indexOfLastDot);
MyClassInfo declaringType = FindNamespaceMember(declaringTypeFullName);
Debug.Assert(declaringType != null, "Declaring type of a nested type must be present.");
MyNestedTypeInfo myNestedTypeInfo = declaringType.GetNestedTypeMember(myClassInfo);
Debug.Assert(myNestedTypeInfo != null, "Impossible! This nested type must be there.");
myNestedTypeInfo.Summary = myClassInfo.Summary;
}
if (myClassInfo is MyDelegateInfo)
{
MyDelegateInfo myDelegateInfo = (MyDelegateInfo)myClassInfo;
// returns node
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");
if (myDelegateInfo.ReturnTypeFullName.ToLower() != "system.void")
{
myDelegateInfo.ReturnValueSummary = returnValueSummary;
}
else if (returnValueSummary != "")
{
Logger.Warning("(XML) There's a description of return value for delegate '{0}' but this delegate returns nothing.", xmlMemberId);
}
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myDelegateInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
}
// typeparam nodes
XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
while (typeParamNodes.MoveNext())
{
string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
if (typeParamName == null)
{
Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
continue;
}
MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myClassInfo, typeParamName);
if (myGenericParameterInfo == null)
{
Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
continue;
}
myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
}
myClassInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'M':
{
MyInvokableMemberInfo myInvokableMemberInfo = FindMethodOrConstructor(xmlMemberId);
if (myInvokableMemberInfo == null)
{
Logger.Warning("(XML) Couldn't locate invokable member '{0}'.", xmlMemberId);
break;
}
myInvokableMemberInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myInvokableMemberInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
if (myInvokableMemberInfo is MyMethodInfo)
{
MyMethodInfo myMethodInfo = (MyMethodInfo)myInvokableMemberInfo;
// returns node
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");
if (myMethodInfo.ReturnTypeFullName.ToLower() != "system.void")
{
myMethodInfo.ReturnValueSummary = returnValueSummary;
}
else if (returnValueSummary != "")
{
Logger.Warning("(XML) There's a description of return value for method '{0}' but this method/constructor returns nothing.", xmlMemberId);
}
// typeparam nodes
XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
while (typeParamNodes.MoveNext())
{
string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
if (typeParamName == null)
{
Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
continue;
}
MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myMethodInfo, typeParamName);
if (myGenericParameterInfo == null)
{
Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
continue;
}
myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
}
}
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myInvokableMemberInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
// exception nodes
XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
while (exceptionNodes.MoveNext())
{
string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
if (exceptionCref == null)
{
Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
continue;
}
int indexOfColon = exceptionCref.IndexOf(':');
if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
{
exceptionCref = exceptionCref.Substring(indexOfColon + 1);
}
MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
if (exceptionClassInfo != null)
{
myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
}
else
{
myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
}
}
// example nodes
myInvokableMemberInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'F':
{
MyFieldInfo myFieldInfo = FindField(xmlMemberId);
if (myFieldInfo == null)
{
Logger.Warning("(XML) Couldn't locate field '{0}'.", xmlMemberId);
break;
}
myFieldInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myFieldInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
myFieldInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'P':
{
MyPropertyInfo myPropertyInfo = FindProperty(xmlMemberId);
if (myPropertyInfo == null)
{
Logger.Warning("(XML) Couldn't locate property '{0}'.", xmlMemberId);
break;
}
myPropertyInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myPropertyInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "value");
myPropertyInfo.ReturnValueSummary = returnValueSummary;
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myPropertyInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
// exception nodes
XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
while (exceptionNodes.MoveNext())
{
string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
if (exceptionCref == null)
{
Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
continue;
}
int indexOfColon = exceptionCref.IndexOf(':');
if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
{
exceptionCref = exceptionCref.Substring(indexOfColon + 1);
}
MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
if (exceptionClassInfo != null)
{
myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
}
else
{
myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
}
}
myPropertyInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'E':
{
MyEventInfo myEventInfo = FindEvent(xmlMemberId);
if (myEventInfo == null)
{
Logger.Warning("(XML) Couldn't locate event '{0}'.", xmlMemberId);
break;
}
myEventInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myEventInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
myEventInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case '!':
{
// shouldn't normally happen; exclamation mark is not used in members
// but for example in crefs
Logger.Warning("(XML) There is a member which couldn't be resolved by Visual Studio: '{0}'.", xmlMemberId);
break;
}
case 'N':
{
// shouldn't normally happen; namespaces can't normally have comments
// but for example documentation files for .NET Framework contain such members (sic!)
MyNamespaceInfo myNamespaceInfo = FindNamespace(xmlMemberId);
if (myNamespaceInfo == null)
{
Logger.Warning("(XML) Couldn't locate namespace '{0}'.", xmlMemberId);
break;
}
myNamespaceInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
break;
}
default:
{
Logger.Warning("Couldn't recognize type of a member ('{0}').", memberType);
break;
}
}
}
public void ReadAssembly(string assemblyAbsolutePath)
{
AssemblyDefinition assembly = AssemblyFactory.GetAssembly(assemblyAbsolutePath);
string assemblyName = assembly.Name.Name;
if (assemblyName != name)
{
Logger.Error("Can't load contents of an assembly to another assembly which has different name.");
return;
}
List<TypeDefinition> types = Utils.GetAllTypes(assembly);
foreach (TypeDefinition typeDefinition in types)
{
if (!Utils.ShouldIncludeType(typeDefinition))
{
continue;
}
if (string.IsNullOrEmpty(typeDefinition.Namespace) && typeDefinition.FullName == MyClassInfo.SPECIAL_MODULE_CLASS_NAME)
{
// skip the special <Module> class
continue;
}
MyNamespaceInfo namespaceInfo;
string typeNamespace = Utils.GetTypeNamespace(typeDefinition);
if (namespaces == null)
{
namespaces = new Dictionary<string, MyNamespaceInfo>();
}
if (!namespaces.ContainsKey(typeNamespace))
{
namespaceInfo = new MyNamespaceInfo(typeNamespace, assemblyName);
namespaces.Add(typeNamespace, namespaceInfo);
}
else
{
namespaceInfo = namespaces[typeNamespace];
}
namespaceInfo.AddType(typeDefinition);
}
}
