public ReflectionEvent(EventInfo eventInfo, IClass declaringType) : base(declaringType, eventInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, eventInfo.EventHandlerType, false);
// get modifiers
MethodInfo methodBase = null;
try
{
methodBase = eventInfo.GetAddMethod(true);
}
catch (Exception) { }
if (methodBase == null)
{
try
{
methodBase = eventInfo.GetRemoveMethod(true);
}
catch (Exception) { }
}
ModifierEnum modifiers = ModifierEnum.None;
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 || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
}
else
{
// assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
this.Modifiers = modifiers;
}
public ReflectionParameter(ParameterInfo parameterInfo, IMember member) : base(parameterInfo.Name)
{
Type type = parameterInfo.ParameterType;
this.ReturnType = ReflectionReturnType.Create(member, type, false);
if (parameterInfo.IsOut)
{
this.Modifiers = ParameterModifiers.Out;
}
else if (type.IsByRef)
{
this.Modifiers = ParameterModifiers.Ref;
}
if (parameterInfo.IsOptional)
{
this.Modifiers |= ParameterModifiers.Optional;
}
if (type.IsArray && type != typeof(Array))
{
foreach (CustomAttributeData data in CustomAttributeData.GetCustomAttributes(parameterInfo))
{
if (data.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName)
{
this.Modifiers |= ParameterModifiers.Params;
break;
}
}
}
}
internal void AddConstraintsFromType(ITypeParameter tp, Type type)
{
foreach (Type constraint in type.GetGenericParameterConstraints())
{
if (tp.Method != null)
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Method, constraint, false));
}
else
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Class, constraint, false));
}
}
}
internal static void AddAttributes(IProjectContent pc, IList <IAttribute> list, IList <CustomAttributeData> attributes)
{
foreach (CustomAttributeData att in attributes)
{
DefaultAttribute a = new DefaultAttribute(att.Constructor.DeclaringType.FullName);
foreach (CustomAttributeTypedArgument arg in att.ConstructorArguments)
{
IReturnType type = ReflectionReturnType.Create(pc, null, arg.ArgumentType, false);
a.PositionalArguments.Add(new AttributeArgument(type, arg.Value));
}
foreach (CustomAttributeNamedArgument arg in att.NamedArguments)
{
IReturnType type = ReflectionReturnType.Create(pc, null, arg.TypedValue.ArgumentType, false);
a.NamedArguments.Add(arg.MemberInfo.Name, new AttributeArgument(type, arg.TypedValue.Value));
}
list.Add(a);
}
}
public ReflectionField(FieldInfo fieldInfo, IClass declaringType) : base(declaringType, fieldInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, fieldInfo.FieldType, false);
ModifierEnum modifiers = ModifierEnum.None;
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 || fieldInfo.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (fieldInfo.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (fieldInfo.IsLiteral)
{
modifiers |= ModifierEnum.Const;
}
this.Modifiers = modifiers;
}
public ReflectionClass(ICompilationUnit compilationUnit, Type type, string fullName, IClass declaringType) : base(compilationUnit, declaringType)
{
if (fullName.Length > 2 && fullName[fullName.Length - 2] == '`')
{
FullyQualifiedName = fullName.Substring(0, fullName.Length - 2);
}
else
{
FullyQualifiedName = fullName;
}
this.UseInheritanceCache = true;
try
{
AddAttributes(compilationUnit.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(type));
}
catch (Exception ex)
{
HostCallback.ShowError("Error reading custom attributes", ex);
}
// set classtype
if (type.IsInterface)
{
this.ClassType = ClassType.Interface;
}
else if (type.IsEnum)
{
this.ClassType = ClassType.Enum;
}
else if (type.IsValueType)
{
this.ClassType = ClassType.Struct;
}
else if (IsDelegate(type))
{
this.ClassType = ClassType.Delegate;
}
else
{
this.ClassType = ClassType.Class;
ApplySpecialsFromAttributes(this);
}
if (type.IsGenericTypeDefinition)
{
foreach (Type g in type.GetGenericArguments())
{
this.TypeParameters.Add(new DefaultTypeParameter(this, g));
}
int i = 0;
foreach (Type g in type.GetGenericArguments())
{
AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
ModifierEnum modifiers = ModifierEnum.None;
if (type.IsNestedAssembly)
{
modifiers |= ModifierEnum.Internal;
}
if (type.IsSealed)
{
modifiers |= ModifierEnum.Sealed;
}
if (type.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
if (type.IsNestedPrivate)
{ // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
}
else if (type.IsNestedFamily)
{
modifiers |= ModifierEnum.Protected;
}
else if (type.IsNestedPublic || type.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else if (type.IsNotPublic)
{
modifiers |= ModifierEnum.Internal;
}
else if (type.IsNestedFamORAssem || type.IsNestedFamANDAssem)
{
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
this.Modifiers = modifiers;
// set base classes
if (type.BaseType != null)
{ // it's null for System.Object ONLY !!!
BaseTypes.Add(ReflectionReturnType.Create(this, type.BaseType, false));
}
foreach (Type iface in type.GetInterfaces())
{
BaseTypes.Add(ReflectionReturnType.Create(this, iface, false));
}
InitMembers(type);
}
public ReflectionMethod(MethodBase methodBase, ReflectionClass declaringType)
: base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name)
{
if (methodBase is MethodInfo)
{
this.ReturnType = ReflectionReturnType.Create(this, ((MethodInfo)methodBase).ReturnType, false);
}
else if (methodBase is ConstructorInfo)
{
this.ReturnType = DeclaringType.DefaultReturnType;
}
foreach (ParameterInfo paramInfo in methodBase.GetParameters())
{
this.Parameters.Add(new ReflectionParameter(paramInfo, this));
}
if (methodBase.IsGenericMethodDefinition)
{
foreach (Type g in methodBase.GetGenericArguments())
{
this.TypeParameters.Add(new DefaultTypeParameter(this, g));
}
int i = 0;
foreach (Type g in methodBase.GetGenericArguments())
{
declaringType.AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
this.Modifiers = modifiers;
ReflectionClass.AddAttributes(declaringType.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(methodBase));
ApplySpecialsFromAttributes(this);
}
public ReflectionProperty(PropertyInfo propertyInfo, IClass declaringType) : base(declaringType, propertyInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, propertyInfo.PropertyType, false);
CanGet = propertyInfo.CanRead;
CanSet = propertyInfo.CanWrite;
ParameterInfo[] parameterInfo = propertyInfo.GetIndexParameters();
if (parameterInfo != null && parameterInfo.Length > 0)
{
// check if this property is an indexer (=default member of parent class)
foreach (MemberInfo memberInfo in propertyInfo.DeclaringType.GetDefaultMembers())
{
if (memberInfo == propertyInfo)
{
this.IsIndexer = true;
break;
}
}
// there are only few properties with parameters, so we can load them immediately
foreach (ParameterInfo info in parameterInfo)
{
this.Parameters.Add(new ReflectionParameter(info, this));
}
}
MethodInfo methodBase = null;
try {
methodBase = propertyInfo.GetGetMethod(true);
} catch (Exception) {}
if (methodBase == null)
{
try {
methodBase = propertyInfo.GetSetMethod(true);
} catch (Exception) {}
}
ModifierEnum modifiers = ModifierEnum.None;
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 || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
}
else // assume public property, if no methodBase could be get.
{
modifiers = ModifierEnum.Public;
}
this.Modifiers = modifiers;
}
