static private GetAttributeUsage ( RuntimeType decoratedAttribute ) : |
||
decoratedAttribute | RuntimeType | |
return |
private static bool AttributeUsageCheck(RuntimeType attributeType, bool mustBeInheritable, object[] attributes, IList derivedAttributes) { AttributeUsageAttribute attributeUsageAttribute = null; if (mustBeInheritable) { attributeUsageAttribute = CustomAttribute.GetAttributeUsage(attributeType); if (!attributeUsageAttribute.Inherited) { return(false); } } if (derivedAttributes == null) { return(true); } for (int i = 0; i < derivedAttributes.Count; i++) { if (derivedAttributes[i].GetType() == attributeType) { if (attributeUsageAttribute == null) { attributeUsageAttribute = CustomAttribute.GetAttributeUsage(attributeType); } return(attributeUsageAttribute.AllowMultiple); } } return(true); }
static internal bool IsDefined(MemberInfo member, Type caType, bool inherit) { if (member == null) { throw new ArgumentNullException("member"); } bool isDefined = CustomAttribute.IsDefined(member, caType); if (isDefined) { return(true); } if (inherit) { AttributeUsageAttribute usage = CustomAttribute.GetAttributeUsage(caType); if (!usage.Inherited) { return(false); // kill the inheritance request, the attribute does not allow for it } // walk up the inheritance chain and look for the specified type switch (member.MemberType) { case MemberTypes.Method: { RuntimeMethodInfo baseMethod = ((MethodInfo)member).GetParentDefinition() as RuntimeMethodInfo; while (baseMethod != null) { isDefined = CustomAttribute.IsDefined(baseMethod, caType); if (isDefined) { return(true); } baseMethod = baseMethod.GetParentDefinition() as RuntimeMethodInfo; } break; } case MemberTypes.TypeInfo: case MemberTypes.NestedType: { RuntimeType baseType = ((Type)member).BaseType as RuntimeType; while (baseType != null) { isDefined = CustomAttribute.IsDefined((MemberInfo)baseType, caType); if (isDefined) { return(true); } baseType = ((Type)baseType).BaseType as RuntimeType; } break; } } } return(false); }
static internal Object[] GetCustomAttributes(MemberInfo member, Type caType, bool inherit) { if (member == null) { throw new ArgumentNullException("member"); } CustomAttribute caItem = GetCustomAttributeList(member, caType, null, 0); // if we are asked to go up the hierarchy chain we have to do it now and regardless of the // attribute usage for the specific attribute because a derived attribute may ovveride the usage... // ... however if the attribute is sealed we can rely on the attribute usage if (caType != null && caType.IsSealed && inherit) { AttributeUsageAttribute usage = CustomAttribute.GetAttributeUsage(caType); if (!usage.Inherited) { inherit = false; // kill the inheritance request, the attribute does not allow for it } } if (inherit) { // walk up the inheritance chain and keep accumulating attributes int level = 1; switch (member.MemberType) { case MemberTypes.Method: { RuntimeMethodInfo baseMethod = ((MethodInfo)member).GetParentDefinition() as RuntimeMethodInfo; while (baseMethod != null) { caItem = GetCustomAttributeList(baseMethod, caType, caItem, level++); baseMethod = baseMethod.GetParentDefinition() as RuntimeMethodInfo; } break; } case MemberTypes.TypeInfo: case MemberTypes.NestedType: { RuntimeType baseType = ((Type)member).BaseType as RuntimeType; while (baseType != null) { caItem = GetCustomAttributeList((MemberInfo)baseType, caType, caItem, level++); baseType = ((Type)baseType).BaseType as RuntimeType; } break; } } } return(CustomAttribute.CheckConsistencyAndCreateArray(caItem, caType)); }
internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit) { if (type.GetElementType() != null) { if (!caType.IsValueType) { return(CustomAttribute.CreateAttributeArrayHelper(caType, 0)); } return(EmptyArray <object> .Value); } else { if (type.IsGenericType && !type.IsGenericTypeDefinition) { type = (type.GetGenericTypeDefinition() as RuntimeType); } int i = 0; Attribute[] customAttributes = PseudoCustomAttribute.GetCustomAttributes(type, caType, true, out i); if (!inherit || (caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited)) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, i, caType, !CustomAttribute.AllowCriticalCustomAttributes(type)); if (i > 0) { Array.Copy(customAttributes, 0, customAttributes2, customAttributes2.Length - i, i); } return(customAttributes2); } List <object> list = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == null || caType.IsValueType || caType.ContainsGenericParameters) ? typeof(object) : caType; while (i > 0) { list.Add(customAttributes[--i]); } while (type != (RuntimeType)typeof(object) && type != null) { object[] customAttributes3 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, 0, caType, mustBeInheritable, list, !CustomAttribute.AllowCriticalCustomAttributes(type)); mustBeInheritable = true; for (int j = 0; j < customAttributes3.Length; j++) { list.Add(customAttributes3[j]); } type = (type.BaseType as RuntimeType); } object[] array = CustomAttribute.CreateAttributeArrayHelper(elementType, list.Count); Array.Copy(list.ToArray(), 0, array, 0, list.Count); return(array); } }
internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit) { if (type.GetElementType() != (Type)null) { if (!caType.IsValueType) { return(CustomAttribute.CreateAttributeArrayHelper((Type)caType, 0)); } return(EmptyArray <object> .Value); } if (type.IsGenericType && !type.IsGenericTypeDefinition) { type = type.GetGenericTypeDefinition() as RuntimeType; } int count = 0; Attribute[] customAttributes1 = PseudoCustomAttribute.GetCustomAttributes(type, caType, true, out count); if (!inherit || caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, count, caType, !CustomAttribute.AllowCriticalCustomAttributes(type)); if (count > 0) { Array.Copy((Array)customAttributes1, 0, (Array)customAttributes2, customAttributes2.Length - count, count); } return(customAttributes2); } List <object> objectList = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == (RuntimeType)null || caType.IsValueType ? 1 : (caType.ContainsGenericParameters ? 1 : 0)) != 0 ? typeof(object) : (Type)caType; while (count > 0) { objectList.Add((object)customAttributes1[--count]); } for (; type != (RuntimeType)typeof(object) && type != (RuntimeType)null; type = type.BaseType as RuntimeType) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, 0, caType, mustBeInheritable, (IList)objectList, !CustomAttribute.AllowCriticalCustomAttributes(type)); mustBeInheritable = true; for (int index = 0; index < customAttributes2.Length; ++index) { objectList.Add(customAttributes2[index]); } } object[] attributeArrayHelper = CustomAttribute.CreateAttributeArrayHelper(elementType, objectList.Count); Array.Copy((Array)objectList.ToArray(), 0, (Array)attributeArrayHelper, 0, objectList.Count); return(attributeArrayHelper); }
internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, bool inherit) { if (method.IsGenericMethod && !method.IsGenericMethodDefinition) { method = (method.GetGenericMethodDefinition() as RuntimeMethodInfo); } int i = 0; Attribute[] customAttributes = PseudoCustomAttribute.GetCustomAttributes(method, caType, true, out i); if (!inherit || (caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited)) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(method.GetRuntimeModule(), method.MetadataToken, i, caType, !CustomAttribute.AllowCriticalCustomAttributes(method)); if (i > 0) { Array.Copy(customAttributes, 0, customAttributes2, customAttributes2.Length - i, i); } return(customAttributes2); } List <object> list = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == null || caType.IsValueType || caType.ContainsGenericParameters) ? typeof(object) : caType; while (i > 0) { list.Add(customAttributes[--i]); } while (method != null) { object[] customAttributes3 = CustomAttribute.GetCustomAttributes(method.GetRuntimeModule(), method.MetadataToken, 0, caType, mustBeInheritable, list, !CustomAttribute.AllowCriticalCustomAttributes(method)); mustBeInheritable = true; for (int j = 0; j < customAttributes3.Length; j++) { list.Add(customAttributes3[j]); } method = method.GetParentDefinition(); } object[] array = CustomAttribute.CreateAttributeArrayHelper(elementType, list.Count); Array.Copy(list.ToArray(), 0, array, 0, list.Count); return(array); }
internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, bool inherit) { if (method.IsGenericMethod && !method.IsGenericMethodDefinition) { method = method.GetGenericMethodDefinition() as RuntimeMethodInfo; } int count = 0; Attribute[] customAttributes1 = PseudoCustomAttribute.GetCustomAttributes(method, caType, true, out count); if (!inherit || caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(method.GetRuntimeModule(), method.MetadataToken, count, caType, !CustomAttribute.AllowCriticalCustomAttributes((MethodBase)method)); if (count > 0) { Array.Copy((Array)customAttributes1, 0, (Array)customAttributes2, customAttributes2.Length - count, count); } return(customAttributes2); } List <object> objectList = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == (RuntimeType)null || caType.IsValueType ? 1 : (caType.ContainsGenericParameters ? 1 : 0)) != 0 ? typeof(object) : (Type)caType; while (count > 0) { objectList.Add((object)customAttributes1[--count]); } for (; (MethodInfo)method != (MethodInfo)null; method = method.GetParentDefinition()) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(method.GetRuntimeModule(), method.MetadataToken, 0, caType, mustBeInheritable, (IList)objectList, !CustomAttribute.AllowCriticalCustomAttributes((MethodBase)method)); mustBeInheritable = true; for (int index = 0; index < customAttributes2.Length; ++index) { objectList.Add(customAttributes2[index]); } } object[] attributeArrayHelper = CustomAttribute.CreateAttributeArrayHelper(elementType, objectList.Count); Array.Copy((Array)objectList.ToArray(), 0, (Array)attributeArrayHelper, 0, objectList.Count); return(attributeArrayHelper); }
// does some consisitency check between the CA list and every CA attribute usage and after // discarding unwanted CA return an array of them static private Object[] CheckConsistencyAndCreateArray(CustomAttribute caItem, Type caType) { // we got the max number of attributes, we may have to trim this list but let's get a count for now if (caItem == null) { return((caType == null || caType.IsValueType) ? s_gObjectEmptyArray : (Object[])Array.CreateInstance(caType, 0)); } int caCount = 0; int hasInherited = (caItem == null) ? 0 : caItem.m_inheritLevel; CustomAttribute caNext = caItem; CustomAttribute caPrev = null; // walk and revert the list while (caNext != null) { caCount++; CustomAttribute caTemp = caNext.m_next; caNext.m_next = caPrev; caPrev = caNext; caNext = caTemp; } caItem = caPrev; // now we have a list of custom attribute of some type. That list may contain subtype of the specific // type, so for every other type we have to go and check whether multiple and inherited are respected if (caCount > 0 && hasInherited > 0) { // keep track of the CA types so we can make inspection reasonable fast Hashtable htCAData = new Hashtable(11); // loop through the list of attributes checking for consistency, once an attribute // has been inspected is never going to be looked at again, and neither an attribute // of the same type. // This loop and the inspectedCATypes array should make that happen caNext = caItem; CustomAttribute caLast = null; while (caNext != null) { AttributeUsageAttribute usage = null; int caTypeLevelFound = 0; // get current attribute type Type t = caNext.GetAttributeType(); // look if the type has already been seen CAData caData = (CAData)htCAData[t]; if (caData != null) { usage = caData.usage; caTypeLevelFound = caData.level; } if (usage == null) { // no type found, load the attribute usage // do not save the attribute usage yet because the next block may discard // the attribute which implies we pretend we never saw. That is kind of // bad because we may end up reloading it again if another type comes into the picture // but we prefer the perf hit to more code complication for a case that seem to // be submarginal usage = CustomAttribute.GetAttributeUsage(t); } // if this is an inherited attribute and the attribute usage does not allow that, OR // if the attribute was seen already on a different inheritance level and multiple is not allowed // THEN discard if ((caNext.m_inheritLevel > 0 && !usage.Inherited) || (caData != null && caTypeLevelFound < caNext.m_inheritLevel && !usage.AllowMultiple)) { if (caLast == null) { caItem = caNext.m_next; } else { caLast.m_next = caNext.m_next; } caNext = caNext.m_next; caCount--; continue; } if (caData == null) { // the attribute was never seen so far so we should add it to the table and keep going htCAData[t] = new CAData(t, usage, caNext.m_inheritLevel); } caLast = caNext; caNext = caNext.m_next; } } // time to return the array if (caCount > 0) { if (caType == null || caType.IsValueType) { caType = s_ObjectType; } Object[] cas = (Object[])Array.CreateInstance(caType, caCount); caNext = caItem; for (int i = 0; i < caCount; i++) { cas[i] = caNext.GetObject(); caNext = caNext.m_next; } return(cas); } else { return((caType == null || caType.IsValueType) ? s_gObjectEmptyArray : (Object[])Array.CreateInstance(caType, 0)); } }
private static void VerifyPseudoCustomAttribute(RuntimeType pca) { AttributeUsageAttribute attributeUsage = CustomAttribute.GetAttributeUsage(pca); }
private static void VerifyPseudoCustomAttribute(Type pca) { CustomAttribute.GetAttributeUsage(pca as RuntimeType); }