public XmlNode GetDocumentation(ConstructorDef constructorDef)
{
ConstructorInfo constructorInfo = constructorDef.ConstructorInfo;
string key = "M:" + constructorDef.GetXMLName();
return((DefinedMembers.ContainsKey(key)) ? DefinedMembers[key] : null);
}
private ConstructorDef ParseConstructor(ConstructorDeclarationSyntax constructorSyntax, SemanticModel semanticModel)
{
var constructorDef = new ConstructorDef();
constructorDef.Internal = constructorSyntax;
constructorDef.AccessLevel = ParseAccessLevel(constructorSyntax.Modifiers) ?? AccessLevel.Private;
constructorDef.IsStatic = constructorSyntax.Modifiers.Any(x => x.ValueText == "static");
if (constructorSyntax.Initializer != null)
{
constructorDef.Initializer = new ConstructorInitializer
{
ThisOrBase = constructorSyntax.Initializer.ThisOrBaseKeyword.ValueText,
};
constructorDef.Initializer.Internal = constructorSyntax.Initializer;
}
foreach (var parameter in constructorSyntax.ParameterList.Parameters)
{
constructorDef.Parameters.Add(ParseParameter(parameter, semanticModel));
}
return(constructorDef);
}
/// <summary>
/// Views one of the constructors defined on the item
/// </summary>
/// <param name="index"></param>
private void ViewConstructor(int index)
{
m_CurrentCtor = m_Item.AdditionalCtors[index] as ConstructorDef;
m_Param1 = AddParam(m_CurrentCtor.Param1, new Point(4, 20));
if (m_CurrentCtor.Param2 != null)
{
m_Param2 = AddParam(m_CurrentCtor.Param2, new Point(104, 20));
}
}
public static void WriteConstructor(StreamWriter writeTo, ConstructorDef constructorDef)
{
writeTo.Write(
".. csharpdocsconstructor:: "
+ constructorDef.ParentClass.TypeDef.GetDocName() + "("
);
// Opis parametrów
bool first = true;
foreach (var param in constructorDef.Params)
{
if (!first)
{
writeTo.Write(", ");
}
writeTo.Write(param.TypeDef.GetDocFullName() + " " + param.Name);
if (param.HasDefault)
{
writeTo.Write("=" + param.DefaultValue);
}
first = false;
}
writeTo.Write(")");
writeTo.Write(
"\n :access: " + AccessTypeM.GetName(constructorDef.AccessType)
);
for (int i = 0; i < constructorDef.Params.Count; i++)
{
writeTo.Write(
"\n :param(" + (i + 1) + "): "
+ constructorDef.Params[i].Description
);
}
// Podsumowanie
writeTo.Write("\n\t\n\t" + constructorDef.Summary);
// Końcowy odstęp
writeTo.Write("\n\n\n");
}
protected void ProcessMemberDataM(XmlNode memberNode)
{
// Szczytywanie ogólnych danych
var name = memberNode.Attributes["name"].InnerText.Split(':')[1];
string fullName;
string paramsString;
// Oddzielenie parametrów od nazwy
string[] tmp = name.Split('(');
fullName = tmp[0];
paramsString = tmp[1].Substring(0, tmp[1].Length - 1);
int lastDot = fullName.LastIndexOf('.');
string className = fullName.Substring(0, lastDot);
name = fullName.Substring(lastDot + 1);
// Pobieranie klasy rodzica
Type classType = Type.GetType(className + ", " + AssemblyDef.AssemblyName);
// Pobieranie definicji klasy rodzica
ClassDef parentClass;
if (AssemblyDef.ClassDefs.ContainsKey(classType))
{
parentClass = AssemblyDef.ClassDefs[classType];
}
else
{
parentClass = ClassDef.FromType(classType);
AssemblyDef.ClassDefs.Add(classType, parentClass);
}
// Przetwarzanie listy parametrów
Type parentClassType = parentClass.TypeDef.Type;
Type[] paramsTypes = ProcessParametersString(paramsString);
// Pobieranie informacji o metodzie
if (name != "#ctor")
{
MethodInfo info = parentClassType.GetMethod(name,
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy,
null,
paramsTypes,
null
);
if (info == null)
{
return;
}
// Pobieranie definicji metody
MethodDef def;
if (parentClass.Methods.ContainsKey(info))
{
def = parentClass.Methods[info];
}
else
{
def = MethodDef.FromMethodInfo(parentClass, info);
parentClass.Methods.Add(info, def);
}
// Przetwarzanie danych XML
XmlNode node;
for (int i = 0; i < memberNode.ChildNodes.Count; i++)
{
node = memberNode.ChildNodes[i];
switch (node.Name)
{
case "summary":
def.Summary = node.InnerText;
break;
case "remarks":
def.Remarks = node.InnerText;
break;
case "param":
var paramName = node.Attributes["name"].InnerText;
var paramDef = def.GetParam(paramName);
if (paramDef != null)
{
paramDef.Description = node.InnerText;
}
break;
case "returns":
def.Returns.Description = node.InnerText;
break;
}
}
}
else
{
ConstructorInfo info = parentClassType.GetConstructor(
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
null,
paramsTypes,
null
);
if (info == null)
{
return;
}
// Pobieranie definicji metody
ConstructorDef def;
if (parentClass.Constructors.ContainsKey(info))
{
def = parentClass.Constructors[info];
}
else
{
def = ConstructorDef.FromConstructorInfo(parentClass, info);
parentClass.Constructors.Add(info, def);
}
// Przetwarzanie danych XML
XmlNode node;
for (int i = 0; i < memberNode.ChildNodes.Count; i++)
{
node = memberNode.ChildNodes[i];
switch (node.Name)
{
case "summary":
def.Summary = node.InnerText;
break;
case "remarks":
def.Remarks = node.InnerText;
break;
case "param":
var paramName = node.Attributes["name"].InnerText;
var paramDef = def.GetParam(paramName);
if (paramDef != null)
{
paramDef.Description = node.InnerText;
}
break;
}
}
}
}
public Constructor(ConstructorDef def, BasicNode body)
: base(def, body)
{
}
