public ReflectionParameter(ParameterInfo parameterInfo, XmlNode methodNode)
{
name = parameterInfo.Name;
returnType = new ReflectionReturnType(parameterInfo.ParameterType);
if (parameterInfo.IsOut) {
modifier |= ParameterModifier.Out;
}
Type type = parameterInfo.ParameterType;
if (type.IsArray && type != typeof(Array) && Attribute.IsDefined(parameterInfo, typeof(ParamArrayAttribute), true)) {
modifier |= ParameterModifier.Params;
}
// seems there is no other way to determine a ref parameter
if (type.Name.EndsWith("&")) {
modifier |= ParameterModifier.Ref;
}
if (methodNode != null) {
XmlNode paramDocu = methodNode.SelectSingleNode("Docs/param[@name='" + parameterInfo.Name + "']");
if (paramDocu != null) {
documentation = paramDocu.InnerXml;
}
}
}
public ReflectionEvent(EventInfo eventInfo, XmlDocument docs)
{
FullyQualifiedName = String.Concat(eventInfo.DeclaringType.FullName, ".", eventInfo.Name);
if (docs != null) {
XmlNode node = docs.SelectSingleNode ("/Type/Members/Member[@MemberName='" + eventInfo.Name + "']/Docs/summary");
if (node != null) {
Documentation = node.InnerXml;
}
}
// get modifiers
MethodInfo methodBase = null;
try {
methodBase = eventInfo.GetAddMethod(true);
} catch (Exception) {}
if (methodBase == null) {
try {
methodBase = eventInfo.GetRemoveMethod(true);
} catch (Exception) {}
}
if (methodBase != null) {
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (methodBase.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
} else { // assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
returnType = new ReflectionReturnType(eventInfo.EventHandlerType );
}
public ReflectionField(FieldInfo fieldInfo, XmlDocument docs)
{
System.Diagnostics.Debug.Assert(fieldInfo != null);
FullyQualifiedName = String.Concat(fieldInfo.DeclaringType.FullName, ".", fieldInfo.Name);
if (docs != null) {
XmlNode node = docs.SelectSingleNode ("/Type/Members/Member[@MemberName='" + fieldInfo.Name + "']/Docs/summary");
if (node != null) {
Documentation = node.InnerXml;
}
}
if (fieldInfo.IsInitOnly) {
modifiers |= ModifierEnum.Readonly;
}
if (fieldInfo.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (fieldInfo.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (fieldInfo.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (fieldInfo.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (fieldInfo.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (fieldInfo.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (fieldInfo.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
if (fieldInfo.IsLiteral) {
modifiers |= ModifierEnum.Const;
}
returnType = new ReflectionReturnType(fieldInfo.FieldType);
}
public ReflectionProperty(PropertyInfo propertyInfo, XmlDocument docs)
{
FullyQualifiedName = String.Concat(propertyInfo.DeclaringType.FullName, ".", propertyInfo.Name);
// show the abstract layer that we have getter & setters
if (propertyInfo.CanRead) {
getterRegion = new DefaultRegion(0, 0, 0, 0);
} else {
getterRegion = null;
}
if (propertyInfo.CanWrite) {
setterRegion = new DefaultRegion(0, 0, 0, 0);
} else {
setterRegion = null;
}
if (docs != null) {
XmlNode node = docs.SelectSingleNode ("/Type/Members/Member[@MemberName='" + propertyInfo.Name + "']/Docs/summary");
if (node != null) {
Documentation = node.InnerXml;
}
}
returnType = new ReflectionReturnType(propertyInfo.PropertyType);
MethodInfo methodBase = null;
try {
methodBase = propertyInfo.GetGetMethod(true);
} catch (Exception) {}
if (methodBase == null) {
try {
methodBase = propertyInfo.GetSetMethod(true);
} catch (Exception) {}
}
if (methodBase != null) {
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (methodBase.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsVirtual) {
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract) {
modifiers |= ModifierEnum.Abstract;
}
} else { // assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
}
/* string GetIndexerName(PropertyInfo propertyInfo)
{
StringBuilder propertyName = new StringBuilder("Item(");
ParameterInfo[] p = propertyInfo.GetIndexParameters();
for (int i = 0; i < p.Length; ++i) {
propertyName.Append(p[i].ParameterType.FullName);
if (i + 1 < p.Length) {
propertyName.Append(',');
}
}
propertyName.Append(')');
return propertyName.ToString();
}
*/
public ReflectionIndexer(PropertyInfo propertyInfo, XmlDocument docs)
{
// indexers does have the same name as the object that declare the indexers
FullyQualifiedName = propertyInfo.DeclaringType.FullName;
// show the abstract layer that we have getter & setters
if (propertyInfo.CanRead) {
getterRegion = new DefaultRegion(0, 0, 0, 0);
} else {
getterRegion = null;
}
if (propertyInfo.CanWrite) {
setterRegion = new DefaultRegion(0, 0, 0, 0);
} else {
setterRegion = null;
}
XmlNode node = null;
if (docs != null) {
node = docs.SelectSingleNode ("/Type/Members/Member[@MemberName='" + propertyInfo.Name + "']");
if (node != null) {
XmlNode docNode = node.SelectSingleNode ("Docs/summary");
if (docNode != null) {
Documentation = node.InnerXml;
}
}
}
returnType = new ReflectionReturnType(propertyInfo.PropertyType);
MethodInfo methodBase = null;
try {
methodBase = propertyInfo.GetGetMethod(true);
} catch (Exception) {}
if (methodBase == null) {
try {
methodBase = propertyInfo.GetSetMethod(true);
} catch (Exception) {}
}
if (methodBase != null) {
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (methodBase.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
} else { // assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
ParameterInfo[] p = propertyInfo.GetIndexParameters();
foreach (ParameterInfo parameterInfo in p) {
parameters.Add(new ReflectionParameter(parameterInfo, node));
}
}
public ReflectionMethod(MethodBase methodBase, XmlDocument docs)
{
string name = methodBase.Name;
if (methodBase is ConstructorInfo) {
name = ".ctor";
}
FullyQualifiedName = String.Concat(methodBase.DeclaringType.FullName, ".", name);
XmlNode node = null;
if (docs != null) {
XmlNodeList nodes = docs.SelectNodes ("/Type/Members/Member[@MemberName='" + name + "']");
if (nodes != null && nodes.Count > 0) {
if (nodes.Count == 1) {
node = nodes[0];
} else {
node = FindMatch (nodes, methodBase);
}
if (node != null) {
XmlNode docNode = node.SelectSingleNode ("Docs/summary");
if (docNode != null) {
Documentation = docNode.InnerXml;
}
}
}
}
modifiers = ModifierEnum.None;
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (methodBase.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsVirtual) {
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract) {
modifiers |= ModifierEnum.Abstract;
}
foreach (ParameterInfo paramInfo in methodBase.GetParameters()) {
parameters.Add(new ReflectionParameter(paramInfo, node));
}
if (methodBase is MethodInfo) {
returnType = new ReflectionReturnType(((MethodInfo)methodBase).ReturnType);
} else {
returnType = null;
}
}
