/// <summary> /// Creates a wrapper. /// </summary> /// <param name="policy">The reflection policy.</param> /// <param name="handle">The underlying reflection object.</param> /// <param name="declaringType">The declaring type.</param> /// <param name="reflectedType">The reflected type.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="policy"/>, <paramref name="handle"/>, /// <paramref name="declaringType"/>, or <paramref name="reflectedType"/> is null.</exception> protected StaticReflectedMemberWrapper(StaticReflectionPolicy policy, object handle, StaticDeclaredTypeWrapper declaringType, StaticDeclaredTypeWrapper reflectedType) : base(policy, handle, declaringType) { if (declaringType == null) throw new ArgumentNullException("declaringType"); if (reflectedType == null) throw new ArgumentNullException("reflectedType"); this.reflectedType = reflectedType; }
/// <summary> /// Creates a wrapper. /// </summary> /// <param name="policy">The reflection policy.</param> /// <param name="handle">The underlying reflection object.</param> /// <param name="declaringType">The declaring type.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="policy"/>, <paramref name="handle"/>, /// or <paramref name="declaringType"/> is null.</exception> public StaticConstructorWrapper(StaticReflectionPolicy policy, object handle, StaticDeclaredTypeWrapper declaringType) : base(policy, handle, declaringType, declaringType) { }
/// <summary> /// Gets the nested types of a type. /// Only includes declared nested types, not inherited ones. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's nested types.</returns> protected internal abstract IEnumerable<StaticTypeWrapper> GetTypeNestedTypes(StaticDeclaredTypeWrapper type);
/// <summary> /// Gets the methods of a type including accessor methods for properties and events. /// Only includes declared methods, not inherited ones. /// </summary> /// <param name="type">The type, not null.</param> /// <param name="reflectedType">The reflected type, not null.</param> /// <returns>The type's methods.</returns> protected internal abstract IEnumerable<StaticMethodWrapper> GetTypeMethods(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType);
/// <summary> /// Gets the generic parameters of a type, including all generic parameters /// of its declaring types if it is nested enumerated from outside in. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's generic parameters.</returns> protected internal abstract IList<StaticGenericParameterWrapper> GetTypeGenericParameters(StaticDeclaredTypeWrapper type);
/// <summary> /// Gets the constructors of a type. /// Only includes declared methods, not inherited ones. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's constructors.</returns> protected internal abstract IEnumerable<StaticConstructorWrapper> GetTypeConstructors(StaticDeclaredTypeWrapper type);
/// <summary> /// Gets the attributes of a type. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type attributes.</returns> protected internal abstract TypeAttributes GetTypeAttributes(StaticDeclaredTypeWrapper type);
protected override string GetTypeNamespace(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) return ""; return typeHandle.GetContainingNamespace().QualifiedName; }
private void BuildTypeGenericParameters(StaticDeclaredTypeWrapper ownerType, ITypeElement typeHandle, List<StaticGenericParameterWrapper> genericParameters) { ITypeElement declaringType = typeHandle.GetContainingType(); if (declaringType != null) BuildTypeGenericParameters(ownerType, declaringType, genericParameters); foreach (ITypeParameter parameterHandle in typeHandle.TypeParameters) genericParameters.Add(StaticGenericParameterWrapper.CreateGenericTypeParameter(this, parameterHandle, ownerType)); }
protected override IList<StaticGenericParameterWrapper> GetTypeGenericParameters(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) return EmptyArray<StaticGenericParameterWrapper>.Instance; var genericParameters = new List<StaticGenericParameterWrapper>(); BuildTypeGenericParameters(type, typeHandle, genericParameters); return genericParameters; }
protected override IList<StaticDeclaredTypeWrapper> GetTypeInterfaces(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) return EmptyArray<StaticDeclaredTypeWrapper>.Instance; List<StaticDeclaredTypeWrapper> interfaces = new List<StaticDeclaredTypeWrapper>(); foreach (IDeclaredType superTypeHandle in SafeGetSuperTypes(typeHandle)) { IInterface @interface = superTypeHandle.GetTypeElement() as IInterface; if (@interface != null) interfaces.Add(MakeDeclaredType(superTypeHandle)); } return interfaces; }
protected override StaticDeclaredTypeWrapper GetTypeBaseType(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) return null; if (!(typeHandle is IInterface)) { foreach (IDeclaredType superTypeHandle in SafeGetSuperTypes(typeHandle)) { IClass @class = superTypeHandle.GetTypeElement() as IClass; if (@class != null) { StaticDeclaredTypeWrapper baseType = MakeDeclaredType(superTypeHandle); // Handles an edge case where the base type is also the containing type of the original type. // This can occur when the original type is nested within its own basetype. // In that case, the containing type should be parameterized by the generic type parameters // of the nested that apply to it. int containingTypeParamCount = baseType.GenericArguments.Count; if (containingTypeParamCount != 0 && IsContainingType(@class, typeHandle)) { var containingTypeArgs = new ITypeInfo[containingTypeParamCount]; IList<ITypeInfo> genericArgs = type.GenericArguments; for (int i = 0; i < containingTypeParamCount; i++) containingTypeArgs[i] = genericArgs[i]; baseType = baseType.MakeGenericType(containingTypeArgs); } return baseType; } } } return null; }
/// <summary> /// Creates a wrapper. /// </summary> /// <param name="policy">The reflection policy.</param> /// <param name="handle">The underlying reflection object.</param> /// <param name="declaringType">The declaring type.</param> /// <param name="reflectedType">The reflected type.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="policy"/>, <paramref name="handle"/>, /// <paramref name="declaringType"/>, or <paramref name="reflectedType"/> is null.</exception> public StaticEventWrapper(StaticReflectionPolicy policy, object handle, StaticDeclaredTypeWrapper declaringType, StaticDeclaredTypeWrapper reflectedType) : base(policy, handle, declaringType, reflectedType) { }
/// <summary> /// Creates a wrapper. /// </summary> /// <param name="policy">The reflection policy.</param> /// <param name="handle">The underlying reflection object.</param> /// <param name="declaringType">The declaring type.</param> /// <param name="reflectedType">The reflected type, or null if none.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="policy"/>, <paramref name="handle"/>, /// <paramref name="declaringType"/>, or <paramref name="reflectedType"/> is null.</exception> protected StaticFunctionWrapper(StaticReflectionPolicy policy, object handle, StaticDeclaredTypeWrapper declaringType, StaticDeclaredTypeWrapper reflectedType) : base(policy, handle, declaringType, reflectedType) { }
protected override TypeAttributes GetTypeAttributes(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement) type.Handle; TypeAttributes flags = 0; ReflectorFlagsUtils.AddFlagIfTrue(ref flags, TypeAttributes.Interface, typeHandle is IInterface); IModifiersOwner modifiers = typeHandle as IModifiersOwner; if (modifiers != null) { ReflectorFlagsUtils.AddFlagIfTrue(ref flags, TypeAttributes.Abstract, modifiers.IsAbstract); ReflectorFlagsUtils.AddFlagIfTrue(ref flags, TypeAttributes.Sealed, modifiers.IsSealed); bool isNested = typeHandle.GetContainingType() != null; switch (modifiers.GetAccessRights()) { case AccessRights.PUBLIC: flags |= isNested ? TypeAttributes.NestedPublic : TypeAttributes.Public; break; case AccessRights.PRIVATE: flags |= isNested ? TypeAttributes.NestedPrivate : TypeAttributes.NotPublic; break; case AccessRights.NONE: case AccessRights.INTERNAL: flags |= isNested ? TypeAttributes.NestedAssembly : TypeAttributes.NotPublic; break; case AccessRights.PROTECTED: flags |= isNested ? TypeAttributes.NestedFamily : TypeAttributes.NotPublic; break; case AccessRights.PROTECTED_AND_INTERNAL: flags |= isNested ? TypeAttributes.NestedFamANDAssem : TypeAttributes.NotPublic; break; case AccessRights.PROTECTED_OR_INTERNAL: flags |= isNested ? TypeAttributes.NestedFamORAssem : TypeAttributes.NotPublic; break; } } if (typeHandle is IDelegate || typeHandle is IEnum || typeHandle is IStruct) flags |= TypeAttributes.Sealed; return flags; }
protected override IEnumerable<StaticConstructorWrapper> GetTypeConstructors(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; bool foundDefault = false; foreach (IConstructor constructorHandle in typeHandle.Constructors) { if (constructorHandle.IsValid()) { if (constructorHandle.IsDefault) { if (typeHandle is IStruct) continue; // Note: Default constructors for structs are not visible via reflection foundDefault = true; } yield return new StaticConstructorWrapper(this, constructorHandle, type); } } if (!foundDefault) { IClass classHandle = typeHandle as IClass; if (classHandle != null && !classHandle.IsStatic) yield return new StaticConstructorWrapper(this, new DefaultConstructor(typeHandle), type); IDelegate delegateHandle = typeHandle as IDelegate; if (delegateHandle != null) yield return new StaticConstructorWrapper(this, new DelegateConstructor(delegateHandle), type); } }
protected override StaticAssemblyWrapper GetTypeAssembly(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; return WrapModule(GetModule(typeHandle)); }
protected override IEnumerable<StaticMethodWrapper> GetTypeMethods(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; foreach (IMethod methodHandle in typeHandle.Methods) { if (methodHandle.IsValid()) yield return new StaticMethodWrapper(this, methodHandle, type, reflectedType, type.Substitution); } foreach (IOperator operatorHandle in typeHandle.Operators) { if (operatorHandle.IsValid()) yield return new StaticMethodWrapper(this, operatorHandle, type, reflectedType, type.Substitution); } foreach (StaticPropertyWrapper property in GetTypeProperties(type, reflectedType)) { if (property.GetMethod != null) yield return property.GetMethod; if (property.SetMethod != null) yield return property.SetMethod; } foreach (StaticEventWrapper @event in GetTypeEvents(type, reflectedType)) { if (@event.AddMethod != null) yield return @event.AddMethod; if (@event.RemoveMethod != null) yield return @event.RemoveMethod; if (@event.RaiseMethod != null) yield return @event.RaiseMethod; } }
/// <summary> /// Gets the assembly that contains a type. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's assembly.</returns> protected internal abstract StaticAssemblyWrapper GetTypeAssembly(StaticDeclaredTypeWrapper type);
protected override IEnumerable<StaticPropertyWrapper> GetTypeProperties(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; foreach (IProperty propertyHandle in typeHandle.Properties) { if (propertyHandle.IsValid()) yield return new StaticPropertyWrapper(this, propertyHandle, type, reflectedType); } }
/// <summary> /// Gets the base type of atype. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The base type.</returns> protected internal abstract StaticDeclaredTypeWrapper GetTypeBaseType(StaticDeclaredTypeWrapper type);
protected override IEnumerable<StaticFieldWrapper> GetTypeFields(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; IClass classHandle = typeHandle as IClass; if (classHandle != null) { foreach (IField fieldHandle in classHandle.Fields) { if (fieldHandle.IsValid()) yield return new StaticFieldWrapper(this, fieldHandle, type, reflectedType); } foreach (IField fieldHandle in classHandle.Constants) { if (fieldHandle.IsValid()) yield return new StaticFieldWrapper(this, fieldHandle, type, reflectedType); } } else { IStruct structHandle = typeHandle as IStruct; if (structHandle != null) { foreach (IField fieldHandle in structHandle.Fields) { if (fieldHandle.IsValid()) yield return new StaticFieldWrapper(this, fieldHandle, type, reflectedType); } foreach (IField fieldHandle in structHandle.Constants) { if (fieldHandle.IsValid()) yield return new StaticFieldWrapper(this, fieldHandle, type, reflectedType); } } } }
/// <summary> /// Gets the events of a type. /// Only includes declared methods, not inherited ones. /// </summary> /// <param name="type">The type, not null.</param> /// <param name="reflectedType">The reflected type, not null.</param> /// <returns>The type's events.</returns> protected internal abstract IEnumerable<StaticEventWrapper> GetTypeEvents(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType);
protected override IEnumerable<StaticEventWrapper> GetTypeEvents(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; foreach (IEvent eventHandle in typeHandle.Events) { if (eventHandle.IsValid()) yield return new StaticEventWrapper(this, eventHandle, type, reflectedType); } }
/// <summary> /// Gets the interfaces directly implemented by a type. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's interfaces.</returns> protected internal abstract IList<StaticDeclaredTypeWrapper> GetTypeInterfaces(StaticDeclaredTypeWrapper type);
protected override IEnumerable<StaticTypeWrapper> GetTypeNestedTypes(StaticDeclaredTypeWrapper type) { ITypeElement typeHandle = (ITypeElement)type.Handle; if (!typeHandle.IsValid()) yield break; foreach (ITypeElement nestedTypeHandle in typeHandle.NestedTypes) { if (nestedTypeHandle.IsValid()) yield return new StaticDeclaredTypeWrapper(this, nestedTypeHandle, type, type.Substitution); } }
/// <summary> /// Gets the namespace that contains a type. /// </summary> /// <param name="type">The type, not null.</param> /// <returns>The type's namespace, or an empty string if it has none.</returns> protected internal abstract string GetTypeNamespace(StaticDeclaredTypeWrapper type);
private StaticDeclaredTypeWrapper MakeDeclaredType(ITypeElement typeElementHandle, ISubstitution substitutionHandle) { if (typeElementHandle is ITypeParameter) throw new ArgumentException("This method should never be called with a generic parameter as input.", "typeElementHandle"); ITypeElement declaringTypeElementHandle = typeElementHandle.GetContainingType(); StaticDeclaredTypeWrapper type; if (declaringTypeElementHandle != null) { StaticDeclaredTypeWrapper declaringType = MakeDeclaredType(declaringTypeElementHandle, substitutionHandle); type = new StaticDeclaredTypeWrapper(this, typeElementHandle, declaringType, declaringType.Substitution); } else { type = new StaticDeclaredTypeWrapper(this, typeElementHandle, null, StaticTypeSubstitution.Empty); } #if ! RESHARPER_50_OR_NEWER var typeParameterHandles = new List<ITypeParameter>(typeElementHandle.AllTypeParameters); #else var typeParameterHandles = new List<ITypeParameter>(typeElementHandle.GetAllTypeParameters()); #endif #if RESHARPER_31 || RESHARPER_40 || RESHARPER_41 if (substitutionHandle.IsIdempotent(typeParameterHandles)) #else if (substitutionHandle.IsIdempotentAll(typeParameterHandles)) #endif { return type; } ITypeInfo[] genericArguments = GenericCollectionUtils.ConvertAllToArray<ITypeParameter, ITypeInfo>(typeParameterHandles, delegate(ITypeParameter typeParameterHandle) { IType substitutedType = substitutionHandle.Apply(typeParameterHandle); if (substitutedType.IsUnknown) return MakeGenericParameterType(typeParameterHandle); return MakeType(substitutedType); }); return type.MakeGenericType(genericArguments); }
/// <summary> /// Gets the properties of a type. /// Only includes declared methods, not inherited ones. /// </summary> /// <param name="type">The type, not null.</param> /// <param name="reflectedType">The reflected type, not null.</param> /// <returns>The type's properties.</returns> protected internal abstract IEnumerable<StaticPropertyWrapper> GetTypeProperties(StaticDeclaredTypeWrapper type, StaticDeclaredTypeWrapper reflectedType);
/// <summary> /// Creates a wrapper. /// </summary> /// <param name="policy">The reflection policy.</param> /// <param name="handle">The underlying reflection object.</param> /// <param name="declaringType">The declaring type, or null if none.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="policy"/> or <paramref name="handle"/> is null.</exception> protected StaticMemberWrapper(StaticReflectionPolicy policy, object handle, StaticDeclaredTypeWrapper declaringType) : base(policy, handle) { this.declaringType = declaringType; }