private void AddMember(IMemberDefinition memberInfo, NodeData parentTypeNode, bool isPrivate)
{
try
{
string memberName = Name.GetMemberFullName(memberInfo);
string parent = isPrivate ? $"{GetParentName(memberName)}.$private" : null;
string description = xmlDocParser.GetDescription(memberName);
NodeData memberNode = new NodeData(memberName, parent, NodeData.MemberType, description);
if (!sentNodes.ContainsKey(memberNode.Name))
{
MembersCount++;
// Not yet sent this node name (properties get/set, events (add/remove) appear twice
sentNodes[memberNode.Name] = memberNode;
nodeCallback(memberNode);
}
AddMemberLinks(memberName, memberInfo);
}
catch (Exception e)
{
Log.Exception(e, $"Failed to add member {memberInfo} in {parentTypeNode?.Name}");
}
}
public IEnumerable <TypeData> AddType(AssemblyDefinition assembly, TypeDefinition type)
{
bool isCompilerGenerated = Name.IsCompilerGenerated(type.Name);
bool isAsyncStateType = false;
NodeData typeNode = null;
if (isCompilerGenerated)
{
// Check if the type is a async state machine type
isAsyncStateType = type.Interfaces.Any(it => it.InterfaceType.Name == "IAsyncStateMachine");
// AsyncStateTypes are only partially included. The state types are not included as nodes,
// but are parsed to extract internal types and references.
if (!isAsyncStateType)
{
// Some other internal compiler generated type, which is ignored for now
// Log.Warn($"Exclude compiler type {type.Name}");
yield break;
}
}
else
{
string name = Name.GetTypeFullName(type);
bool isPrivate = type.Attributes.HasFlag(TypeAttributes.NestedPrivate);
string parent = isPrivate
? $"{NodeName.From(name).ParentName.FullName}.$private" : null;
string description = xmlDockParser.GetDescription(name);
if (IsNameSpaceDocType(type, description))
{
// Type was a namespace doc type, extract it and move to next type
yield break;
}
typeNode = new NodeData(name, parent, NodeData.TypeType, description);
nodeCallback(typeNode);
}
yield return(new TypeData(type, typeNode, isAsyncStateType));
// Iterate all nested types as well
foreach (var nestedType in type.NestedTypes)
{
// Adding a type could result in multiple types
foreach (var types in AddType(assembly, nestedType))
{
yield return(types);
}
}
}