C# MemberInfo.GetCustomAttributes方法代码示例

 public static AttributeMap[] Create(TypeModel model, MemberInfo member, bool inherit)
 {
     #if FEAT_IKVM
     System.Collections.Generic.IList<CustomAttributeData> all = member.__GetCustomAttributes(model.MapType(typeof(Attribute)), inherit);
     AttributeMap[] result = new AttributeMap[all.Count];
     int index = 0;
     foreach (CustomAttributeData attrib in all)
     {
         result[index++] = new AttributeDataMap(attrib);
     }
     return result;
     #else
     #if WINRT
     Attribute[] all = System.Linq.Enumerable.ToArray(member.GetCustomAttributes(inherit));
     #else
     var all = member.GetCustomAttributes(inherit);
     #endif
     var result = new AttributeMap[all.Length];
     for (var i = 0; i < all.Length; i++)
     {
         result[i] = new ReflectionAttributeMap((Attribute) all[i]);
     }
     return result;
     #endif
 }

 private ArgumentHandler ConstructArgumentHandler(MemberInfo info, Argument arg)
 {
     ArgumentHandler ai;
       var memberType = GetMemberType(info);
       var min = 0;
       var max = 0;
       var margs = info.GetCustomAttributes(typeof(MultipleArguments), true) as MultipleArguments[];
       if (margs.Length == 1) {
     min = margs[0].Min;
     max = margs[0].Max;
       }
       if (memberType.IsArray) {
     ai = new ArrayArgumentHandler(this, info, memberType, min, max);
       }
       else if (isIList(memberType)) {
     ai = new IListArgumentHandler(this, info, memberType, min, max);
       }
       else if (memberType == typeof(bool) || memberType == typeof(Boolean) || memberType.IsSubclassOf(typeof(Boolean))) {
     var bargs = info.GetCustomAttributes(typeof(FlagArgument), true) as FlagArgument[];
     ai = new FlagArgumentHandler(this, info, arg.OnCollision, arg.Required, bargs.Length != 0 ? bargs[0].WhenSet : true);
       }
       else if (info.GetCustomAttributes(typeof(CountedArgument), true).Length != 0) {
     ai = new CounterArgumentHandler(this, info, memberType, arg.Required);
       }
       else {
     ai = new PlainArgumentHandler(this, info, memberType, arg.OnCollision, arg.Required);
       }
       return ai;
 }

		public TestMember(TestType uiTestType, MemberInfo memberInfo)
		{
			DeclaringType = uiTestType;
			MemberInfo = memberInfo;

			// handle public overrides that inherit attributes
			uiTestAttributes = memberInfo.GetCustomAttributes<UiTestAttribute>();
			categoryAttributes = memberInfo.GetCustomAttributes<CategoryAttribute>();
		}

		public static IElasticPropertyAttribute Property(MemberInfo info)
		{
			var attributes = info.GetCustomAttributes(typeof(IElasticPropertyAttribute), true);
			if (attributes != null && attributes.Any())
				return ((IElasticPropertyAttribute)attributes.First());

			var ignoreAttrutes = info.GetCustomAttributes(typeof(JsonIgnoreAttribute), true);
			if (ignoreAttrutes != null && ignoreAttrutes.Any())
				return new ElasticPropertyAttribute { OptOut = true };

			return null;
		}

 private static void FillCorrelationAliasAttrs(MemberInfo memberInfo, Hashtable correlationAliasAttrs, ValidationErrorCollection validationErrors)
 {
     foreach (object obj2 in memberInfo.GetCustomAttributes(typeof(CorrelationAliasAttribute), false))
     {
         CorrelationAliasAttribute attributeFromObject = Helpers.GetAttributeFromObject<CorrelationAliasAttribute>(obj2);
         if (string.IsNullOrEmpty(attributeFromObject.Name) || (attributeFromObject.Name.Trim().Length == 0))
         {
             ValidationError item = new ValidationError(SR.GetString(CultureInfo.CurrentCulture, "Error_CorrelationAttributeInvalid", new object[] { typeof(CorrelationAliasAttribute).Name, "Name", memberInfo.Name }), 0x150);
             item.UserData.Add(typeof(CorrelationAliasAttribute), memberInfo.Name);
             validationErrors.Add(item);
         }
         else if (string.IsNullOrEmpty(attributeFromObject.Path) || (attributeFromObject.Path.Trim().Length == 0))
         {
             ValidationError error2 = new ValidationError(SR.GetString(CultureInfo.CurrentCulture, "Error_CorrelationAttributeInvalid", new object[] { typeof(CorrelationAliasAttribute).Name, "Path", memberInfo.Name }), 0x150);
             error2.UserData.Add(typeof(CorrelationAliasAttribute), memberInfo.Name);
             validationErrors.Add(error2);
         }
         else if (correlationAliasAttrs.Contains(attributeFromObject.Name))
         {
             ValidationError error3 = new ValidationError(SR.GetString(CultureInfo.CurrentCulture, "Error_DuplicateCorrelationAttribute", new object[] { typeof(CorrelationAliasAttribute).Name, attributeFromObject.Name, memberInfo.Name }), 0x151);
             error3.UserData.Add(typeof(CorrelationAliasAttribute), memberInfo.Name);
             validationErrors.Add(error3);
         }
         else
         {
             correlationAliasAttrs.Add(attributeFromObject.Name, attributeFromObject);
         }
     }
 }

        private static void AddMember(ServiceAssembly assembly, ServiceTypeFieldCollection result, MemberInfo member, Type memberType)
        {
            var attributes = member.GetCustomAttributes(typeof(ProtoMemberAttribute), true);

            if (attributes.Length == 0)
                return;

            Debug.Assert(attributes.Length == 1);

            var attribute = (ProtoMemberAttribute)attributes[0];

            var shouldSerializeMember = member.DeclaringType.GetMethod(
                "ShouldSerialize" + member.Name,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
            );

            result.Add(new ServiceTypeField(
                assembly,
                ReflectionOptimizer.BuildGetter(member),
                ReflectionOptimizer.BuildSetter(member, true),
                shouldSerializeMember == null ? null : ReflectionOptimizer.BuildShouldSerializeInvoker(shouldSerializeMember),
                attribute.Tag,
                attribute.IsRequired,
                memberType
            ));
        }

		/// <summary>
		/// Implementors should collect the transformfilter information
		/// and return descriptors instances, or an empty array if none
		/// was found.
		/// </summary>
		/// <param name="memberInfo">The action (MethodInfo)</param>
		/// <returns>
		/// An array of <see cref="TransformFilterDescriptor"/>
		/// </returns>
		public TransformFilterDescriptor[] CollectFilters(MemberInfo memberInfo)
		{
			if (logger.IsDebugEnabled)
			{
				logger.DebugFormat("Collecting filters for {0}", memberInfo.Name);
			}

			object[] attributes = memberInfo.GetCustomAttributes(typeof(ITransformFilterDescriptorBuilder), true);

			ArrayList filters = new ArrayList();

			foreach (ITransformFilterDescriptorBuilder builder in attributes)
			{
				TransformFilterDescriptor[] descs = builder.BuildTransformFilterDescriptors();

				if (logger.IsDebugEnabled)
				{
					foreach (TransformFilterDescriptor desc in descs)
					{
						logger.DebugFormat("Collected filter {0} to execute in order {1}",desc.TransformFilterType, desc.ExecutionOrder);
					}
				}

				filters.AddRange(descs);
			}

			return (TransformFilterDescriptor[])filters.ToArray(typeof(TransformFilterDescriptor));
		}

        /// <summary>
        ///   Get attributes for the member.
        /// </summary>
        /// <param name="memberInfo">
        ///   A <b>MemberInfo</b> value.
        /// </param>
        /// <returns>
        ///   A <b>string</b> value contains the attributs for this member.
        /// </returns>
        public static string GetAttributesForMember(MemberInfo memberInfo)
        {
            // Check parameters.
            if (memberInfo == null)
            {
                throw new ArgumentNullException();
            }

            // Get attributes used for this method.
            Object[] attributes = memberInfo.GetCustomAttributes(false);
            if (attributes.Length < 1)
            {
                return null;
            }
            else if (attributes.Length == 1)
            {
                return " (" + attributes[0].GetType().Name + ")";
            }
            else
            {
                string attNames = " (";
                foreach (object o in attributes)
                {
                    attNames += o.GetType().Name + ",";
                }
                attNames = attNames.Substring(0, attNames.Length - 1);
                attNames += ")";
                return attNames;
            }
        }

        /// <summary>
        /// Returns a value indicating whether the value of the specified field will be excluded from a list.
        /// </summary>
        /// <param name="mi">The field to check.</param>
        /// <returns>
        /// true if the value of the specified field will be excleded from a list; otherwise, false.
        /// </returns>
        /// <exception cref="System.NullReferenceException">
        /// Object reference not set to an instance of an object.
        /// </exception>
        public static bool IsExcluded(MemberInfo mi)
        {
            if (mi == null)
                return false;

            return (mi.GetCustomAttributes(typeof(ExcludeAttribute), false).Length > 0);
        }

 private bool ShouldIgnore(MemberInfo member)
 {
     var attr = member.GetCustomAttributes(typeof(SerializeIgnoreAttribute), true).SingleOrDefault();
     if (attr != null)
         return (attr as SerializeIgnoreAttribute).IgnoreTypes.Contains(_ignoreType);
     return false;
 }

      private String GetMemberName (MemberInfo memberInfo)
      {
         DirectApiAttribute directApiAttribute =
            memberInfo.GetCustomAttributes(false).OfType<DirectApiAttribute>().FirstOrDefault();

         return directApiAttribute == null ? memberInfo.Name : directApiAttribute.Name;
      }

        private static bool HasAliasAttribute(string alias, MemberInfo member)
        {
            var attributes = member.GetCustomAttributes(true);
            var dataMember = attributes.OfType<DataMemberAttribute>()
                .FirstOrDefault();
            if (dataMember != null && dataMember.Name == alias)
            {
                return true;
            }

            var xmlElement = attributes.OfType<XmlElementAttribute>()
                .FirstOrDefault();
            if (xmlElement != null && xmlElement.ElementName == alias)
            {
                return true;
            }

            var xmlAttribute = attributes.OfType<XmlAttributeAttribute>()
                .FirstOrDefault();
            if (xmlAttribute != null && xmlAttribute.AttributeName == alias)
            {
                return true;
            }
            return false;
        }

		/// <summary>
		/// Initializes a new instance of the ClassPropInfo class.
		/// </summary>
		/// <param name="memberInfo">The member to represent.</param>
		private ClassPropInfo(MemberInfo memberInfo)
		{
			Type = memberInfo.ReflectedType;
			Name = memberInfo.Name.ToUpperInvariant();

			// try to look up a field with the name
			FieldInfo = memberInfo as FieldInfo;
			if (FieldInfo != null)
			{
				MemberType = FieldInfo.FieldType;
			}
			else
			{
				// get the property
				PropertyInfo p = memberInfo as PropertyInfo;

				// get the getter and setter
				GetMethodInfo = p.GetGetMethod(true);
				SetMethodInfo = p.GetSetMethod(true);

				MemberType = p.PropertyType;
			}

			// see if there is a column attribute defined on the field
			var attribute = memberInfo.GetCustomAttributes(typeof(ColumnAttribute), true).OfType<ColumnAttribute>().FirstOrDefault();
			ColumnName = (attribute != null) ? attribute.ColumnName.ToUpperInvariant() : Name;
		}

        internal bool IsMemberRequired(MemberInfo memberInfo)
        {
            bool retVal = false;

            if (memberInfo.GetCustomAttributes(true).Any(q => q is RequiredAttribute))
            {
                retVal = true;
            }
            else if (true)
            {
                PropertyInfo propertyInfo = memberInfo as PropertyInfo;
                FieldInfo fieldInfo = memberInfo as FieldInfo;

                if (propertyInfo != null)
                {
                    if (propertyInfo.PropertyType.IsValueType &&
                    !(propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>)))
                    {
                        retVal = true;
                    }
                }
                else if (fieldInfo != null)
                {
                    if (fieldInfo.FieldType.IsValueType &&
                    !(fieldInfo.FieldType.IsGenericType && fieldInfo.FieldType.GetGenericTypeDefinition() == typeof(Nullable<>)))
                    {
                        retVal = true;
                    }
                }
            }

            return retVal;
        }

		// Nasty hack to work around not referencing DataAnnotations directly. 
		// At some point investigate the DataAnnotations reference issue in more detail and go back to using the code above. 
		static string GetDisplayName(MemberInfo member) {
			var attributes = (from attr in member.GetCustomAttributes(true)
			                  select new {attr, type = attr.GetType()}).ToList();

			string name = null;

#if !WINDOWS_PHONE
			name = (from attr in attributes
			        where attr.type.Name == "DisplayAttribute"
			        let method = attr.type.GetRuntimeMethod("GetName", new Type[0]) 
			        where method != null
			        select method.Invoke(attr.attr, null) as string).FirstOrDefault();
#endif

#if !SILVERLIGHT
			if (string.IsNullOrEmpty(name)) {
				name = (from attr in attributes
				        where attr.type.Name == "DisplayNameAttribute"
				        let property = attr.type.GetRuntimeProperty("DisplayName")
				        where property != null
				        select property.GetValue(attr.attr, null) as string).FirstOrDefault();
			}
#endif

			return name;
		}