C# ICustomAttributeProvider.IsDefined方法代码示例

 protected IJsonTypeConverter CreateTypeConverter(ICustomAttributeProvider provider)
 {
     if (provider.IsDefined(typeof(JsonConvertAttribute), false))
     {
         JsonConvertAttribute convAttr = (JsonConvertAttribute)provider.GetCustomAttributes(typeof(JsonConvertAttribute), false)[0];
         return CreateTypeConverter(convAttr);
     }
     return null;
 }

 public override void Process(IMetaData metaData, ICustomAttributeProvider attributeProvider, IConfiguration config)
 {
     if (metaData is IPropertyData)
     {
         IPropertyData property = (IPropertyData)metaData;
         if (attributeProvider.IsDefined(typeof(XmlIgnoreAttribute), false))
             property.Ignored = true;
     }
 }

        private static bool GetIsRtimplFromCache(ICustomAttributeProvider cap)
        {
            lock (_isRtimplCache)
            {
                if (!_isRtimplCache.ContainsKey(cap))
                {
                    _isRtimplCache.Add(cap, cap.IsDefined(typeof(RtimplAttribute), false));
                }

                return _isRtimplCache[cap];
            }
        }

        public static IPropertyEditor TryCreate(Type type, ICustomAttributeProvider attributes)
        {
            if (type.IsNullableType()) {
                return new NullablePropertyEditor(type.GetGenericArguments()[0]);
            }

            if (attributes != null &&
                type.IsClass && attributes.IsDefined(typeof(InspectorNullableAttribute), /*inherit:*/true)) {
                return new NullablePropertyEditor(type);
            }

            return null;
        }

 public virtual bool IsByVal(ICustomAttributeProvider icap)
 {
     return icap.IsDefined (typeof (ByValAttribute), false);
 }

		internal static bool IsDefined (ICustomAttributeProvider obj, Type attributeType, bool inherit)
		{
			if (attributeType == null)
				throw new ArgumentNullException ("attributeType");

			AttributeUsageAttribute usage = null;
			do {
				if (IsUserCattrProvider (obj))
					return obj.IsDefined (attributeType, inherit);

				if (IsDefinedInternal (obj, attributeType))
					return true;

				object[] pseudoAttrs = GetPseudoCustomAttributes (obj, attributeType);
				if (pseudoAttrs != null) {
					for (int i = 0; i < pseudoAttrs.Length; ++i)
						if (attributeType.IsAssignableFrom (pseudoAttrs[i].GetType ()))
							return true;
				}

				if (usage == null) {
					if (!inherit)
						return false;

					usage = RetrieveAttributeUsage (attributeType);
					if (!usage.Inherited)
						return false;
				}

				obj = GetBase (obj);
			} while (obj != null);

			return false;
		}

 public static bool IsDeprecated(ICustomAttributeProvider attrProvider)
 {
     return attrProvider.IsDefined (typeof (ObsoleteAttribute), true);
 }

		private static bool IsTypeHierarchyBase(ICustomAttributeProvider type)
		{
			if (type.IsDefined(typeof(JoinedBaseAttribute), false))
			{
				return true;
			}

			object[] attrs = type.GetCustomAttributes(typeof(ActiveRecordAttribute), false);

			if (attrs != null && attrs.Length > 0)
			{
				ActiveRecordAttribute att = (ActiveRecordAttribute) attrs[0];

				return att.DiscriminatorColumn != null;
			}

			return false;
		}

		/// <summary>
		/// Return true if the type has a [ActiveRecord] attribute
		/// </summary>
		private static bool IsActiveRecordType(ICustomAttributeProvider type)
		{
			return type.IsDefined(typeof(ActiveRecordAttribute), false);
		}

 protected override bool IsNonAction(ICustomAttributeProvider action)
 {
     return action.IsDefined(typeof(NonActionAttribute), inherit: true);
 }

 private static bool IsRequired(ICustomAttributeProvider property)
 {
     return property.IsDefined(typeof(RequiredAttribute), false);
 }

		internal static bool IsDefined (ICustomAttributeProvider obj, Type attributeType, bool inherit)
		{
			if (attributeType == null)
				throw new ArgumentNullException ("attributeType");

			if (IsUserCattrProvider (obj))
				return obj.IsDefined (attributeType, inherit);

			if (IsDefinedInternal (obj, attributeType))
				return true;

			object[] pseudoAttrs = GetPseudoCustomAttributes (obj, attributeType);
			if (pseudoAttrs != null) {
				for (int i = 0; i < pseudoAttrs.Length; ++i)
					if (attributeType.IsAssignableFrom (pseudoAttrs [i].GetType ()))
						return true;
			}

#if ONLY_1_1
			if (inherit) {
				AttributeUsageAttribute usage = RetrieveAttributeUsage (attributeType);
				if (!usage.Inherited)
					inherit = false;
			}
#endif

			// FIXME (bug #82431):
			// on 2.0 profile we should always walk the inheritance
			// chain and base the behavior on the inheritance level:
			//
			// 0  : return true if "attributeType" is assignable from
			// any of the custom attributes
			//
			// > 0: return true if "attributeType" is assignable from
			// any of the custom attributes and AttributeUsageAttribute
			// .Inherited of the assignable attribute is true

			ICustomAttributeProvider btype;
			if (inherit && ((btype = GetBase (obj)) != null))
				return IsDefined (btype, attributeType, inherit);

			return false;
		}

 private static string DescriptionOf(ICustomAttributeProvider property)
 {
     if (property.IsDefined(typeof(DescriptionAttribute), false))
     {
         var attribute = (DescriptionAttribute) property.GetCustomAttributes(typeof(DescriptionAttribute), false)[0];
         return attribute.Value;
     }
     return string.Empty;
 }

		public TypeSpec CreateType (Type type, TypeSpec declaringType, ICustomAttributeProvider ca, int dynamicCursor, bool canImportBaseType)
		{
			TypeSpec spec;
			if (import_cache.TryGetValue (type, out spec)) {
				if (ca == null)
					return spec;

				if (type == typeof (object)) {
					if (IsDynamicType (ca, dynamicCursor))
						return InternalType.Dynamic;

					return spec;
				}

				if (!spec.IsGeneric)
					return spec;

#if NET_4_0
				if (!ca.IsDefined (typeof (DynamicAttribute), false))
#endif
					return spec;

				// We've found same object in the cache but this one has a dynamic custom attribute
				// and it's most likely dynamic version of same type IFoo<object> agains IFoo<dynamic>
				// Do resolve the type process again in that case
			}

			if (type.IsGenericType && !type.IsGenericTypeDefinition) {
				var type_def = type.GetGenericTypeDefinition ();
				var targs = CreateGenericArguments (0, type.GetGenericArguments (), ca, dynamicCursor + 1);
				if (declaringType == null) {
					// Simple case, no nesting
					spec = CreateType (type_def, null, null, 0, canImportBaseType);
					spec = spec.MakeGenericType (targs);
				} else {
					//
					// Nested type case, converting .NET types like
					// A`1.B`1.C`1<int, long, string> to typespec like
					// A<int>.B<long>.C<string>
					//
					var nested_hierarchy = new List<TypeSpec> ();
					while (declaringType.IsNested) {
						nested_hierarchy.Add (declaringType);
						declaringType = declaringType.DeclaringType;
					}

					int targs_pos = 0;
					if (declaringType.Arity > 0) {
						spec = declaringType.MakeGenericType (targs.Skip (targs_pos).Take (declaringType.Arity).ToArray ());
						targs_pos = spec.Arity;
					} else {
						spec = declaringType;
					}

					for (int i = nested_hierarchy.Count; i != 0; --i) {
						var t = nested_hierarchy [i - 1];
						spec = MemberCache.FindNestedType (spec, t.Name, t.Arity);
						if (t.Arity > 0) {
							spec = spec.MakeGenericType (targs.Skip (targs_pos).Take (spec.Arity).ToArray ());
							targs_pos += t.Arity;
						}
					}

					string name = type.Name;
					int index = name.IndexOf ('`');
					if (index > 0)
						name = name.Substring (0, index);

					spec = MemberCache.FindNestedType (spec, name, targs.Length - targs_pos);
					if (spec.Arity > 0) {
						spec = spec.MakeGenericType (targs.Skip (targs_pos).ToArray ());
					}
				}

				// Don't add generic type with dynamic arguments, they can interfere with same type
				// using object type arguments
				if (!spec.HasDynamicElement) {

					// Add to reading cache to speed up reading
					if (!import_cache.ContainsKey (type))
						import_cache.Add (type, spec);
				}

				return spec;
			}

			Modifiers mod;
			MemberKind kind;

			var ma = type.Attributes;
			switch (ma & TypeAttributes.VisibilityMask) {
			case TypeAttributes.Public:
			case TypeAttributes.NestedPublic:
				mod = Modifiers.PUBLIC;
				break;
			case TypeAttributes.NestedPrivate:
				mod = Modifiers.PRIVATE;
				break;
			case TypeAttributes.NestedFamily:
				mod = Modifiers.PROTECTED;
//.........这里部分代码省略.........

 public static bool IsDefined(ICustomAttributeProvider provider, Type attributeType)
 {
     return provider.IsDefined(attributeType, true);
 }