C# TypeInfo.GetCustomAttribute方法代码示例

        public static string GetComponentFullName(TypeInfo componentType)
        {
            if (componentType == null)
            {
                throw new ArgumentNullException(nameof(componentType));
            }

            var attribute = componentType.GetCustomAttribute<ViewComponentAttribute>();
            if (!string.IsNullOrEmpty(attribute?.Name))
            {
                return attribute.Name;
            }

            // If the view component didn't define a name explicitly then use the namespace + the
            // 'short name'.
            var shortName = GetShortNameByConvention(componentType);
            if (string.IsNullOrEmpty(componentType.Namespace))
            {
                return shortName;
            }
            else
            {
                return componentType.Namespace + "." + shortName;
            }
        }

        private HarshContentTypeId Build(TypeInfo t)
        {
            if (t.AsType() == typeof(HarshEntity))
            {
                // don't recurse up to Object. we should never get 
                // here anyway, since entities are supposed to inherit from
                // something with an absolute ID specified,
                // not directly from the HarshEntity class. 
                return null;
            }

            var cta = t.GetCustomAttribute<ContentTypeAttribute>(inherit: false);

            if (cta == null)
            {
                if (t == _entityTypeInfo)
                {
                    throw Logger.Fatal.InvalidOperationFormat(
                        SR.ContentTypeIdBuilder_NoContentTypeAttribute,
                        t.FullName
                    );
                }
                else
                {
                    throw Logger.Fatal.InvalidOperationFormat(
                        SR.ContentTypeIdBuilder_NoContentTypeAttributeBaseClass,
                        t.FullName,
                        _entityTypeInfo.FullName
                    );
                }
            }

            var ctid = HarshContentTypeId.Parse(cta.ContentTypeId);

            if (ctid.IsAbsolute)
            {
                // an absolute ID. do not recurse further up the
                // class hierarchy, take it as it is
                return ctid;
            }
            else
            {
                // not an absolute ID, append the parent type ID first
                var result = Build(t.BaseType.GetTypeInfo());

                if (result == null)
                {
                    throw Logger.Fatal.InvalidOperationFormat(
                        SR.ContentTypeIdBuilder_NoAbsoluteIDInHierarchy,
                        _entityTypeInfo.FullName
                    );
                }

                return result.Append(ctid);
            }
        }

        public void AllPublicConcreteTypesShouldBeAnnotatedWithDebuggerDisplay(TypeInfo type)
        {
            var attribute = type.GetCustomAttribute<DebuggerDisplayAttribute>(false);

            Assert.Equal("{DebuggerDisplay, nq}", attribute.Value);

            var debuggerDisplay = type.GetDeclaredProperty("DebuggerDisplay");

            Assert.False(debuggerDisplay.GetAccessors().Any(x => x.IsPublic));
        }

        public TestClassInfo(TypeInfo info) {
 
            if (!info.IsPublic || !info.IsClass) return;
            var attr = info.GetCustomAttribute(typeof(TestAttribute)) as TestAttribute;
            if (attr != null) {
                this.IsValid = true;
                this.TestClassType = info;
                this.Description = attr.Description;
            }
            
        }

 private static bool IsAnonymousType(Type t, TypeInfo ti)
 {
     // This is not a perfect way to detect anonymous classes since they are a compiler feature and not a CLR feature.
     // It is probably good enough though.
     // See also Jon Skeets exhaustive answer on anonymous classes: http://stackoverflow.com/a/315186/271746
     return
         t.Namespace == null &&
         ti.IsPublic == false &&
         t.IsNested == false &&
         ti.IsGenericType &&
         ti.IsSealed &&
         ti.GetCustomAttribute<CompilerGeneratedAttribute>() != null;
 }

 private static TestGroup CreateGroup(TypeInfo type)
 {
     TestGroup group = new TestGroup();
     group.Name = type.Name;
     group.Tags.Add(type.Name);
     group.Tags.Add(type.FullName);
     if (type.GetCustomAttribute<FunctionalTestAttribute>(true) != null)
     {
         group.Tags.Add("Functional");
     }
     foreach (TagAttribute attr in type.GetCustomAttributes<TagAttribute>(true))
     {
         group.Tags.Add(attr.Tag);
     }
     return group;
 }

        public void ProcessType(IContainerConfiguration container, TypeInfo type)
        {
            var settingsAttribute = type.GetCustomAttribute<SettingsAttribute>();
            if (settingsAttribute != null)
            {
                var settingsType = type.AsType();
                var settingsScope = settingsAttribute.Scope;
                var activatorConfiguration = new SettingsActivatorConfiguration(settingsScope, settingsType);

                container.Register(activatorConfiguration);
            }

            foreach (var serviceType in type.ImplementedInterfaces)
            {
                ProcessServiceType(container, type, serviceType);
            }
        }

        /// <summary>
        /// Gets the widget name for the given widget type.
        /// </summary>
        /// <param name="widgetType">The widget type.</param>
        /// <returns>The widget name.</returns>
        public static string GetWidgetName(TypeInfo widgetType)
        {
            if (widgetType == null)
            {
                throw new ArgumentNullException(nameof(widgetType));
            }

            var attr = widgetType.GetCustomAttribute<WidgetAttribute>();
            if (attr != null && !string.IsNullOrEmpty(attr.Name))
            {
                var idx = attr.Name.LastIndexOf('.');
                if (idx >= 0)
                {
                    return attr.Name.Substring(idx + 1);
                }

                return attr.Name;
            }

            return GetShortNameByConvention(widgetType);
        }

        /// <summary>
        /// Gets the widget full name for the given widget type.
        /// </summary>
        /// <param name="widgetType">The widget type.</param>
        /// <returns>The widget full name.</returns>
        public static string GetWidgetFullName(TypeInfo widgetType)
        {
            if (widgetType == null)
            {
                throw new ArgumentNullException(nameof(widgetType));
            }

            var attr = widgetType.GetCustomAttribute<WidgetAttribute>();
            if (attr != null && !string.IsNullOrEmpty(attr.Name))
            {
                return attr.Name;
            }

            var shortName = GetShortNameByConvention(widgetType);
            if (string.IsNullOrEmpty(widgetType.Namespace))
            {
                return shortName;
            }

            return $"{widgetType.Namespace}.{shortName}";
        }

        public static string GetComponentName(TypeInfo componentType)
        {
            if (componentType == null)
            {
                throw new ArgumentNullException(nameof(componentType));
            }

            var attribute = componentType.GetCustomAttribute<ViewComponentAttribute>();
            if (attribute != null && !string.IsNullOrEmpty(attribute.Name))
            {
                var separatorIndex = attribute.Name.LastIndexOf('.');
                if (separatorIndex >= 0)
                {
                    return attribute.Name.Substring(separatorIndex + 1);
                }
                else
                {
                    return attribute.Name;
                }
            }

            return GetShortNameByConvention(componentType);
        }

		public static bool HasJsonUseTypeHintAttribute ( TP tp ) {
#if WINDOWS_STORE
			return tp.GetCustomAttribute<JsonUseTypeHintAttribute> (true) != null;
#else
			return tp.GetCustomAttributes(typeof(JsonUseTypeHintAttribute),true).Length != 0;
#endif
		}

 internal static String GetClassName(TypeInfo type)
 {
     var attribute = type.GetCustomAttribute<AVClassNameAttribute>();
       return attribute != null ? attribute.ClassName : null;
 }

 private static LoginType GetLoginType(TypeInfo typeInfo)
 {
     return typeInfo.GetCustomAttribute<AuthoAttribution>().LoginType;
 }

        /// <summary>
        /// Determines if the given type represents a widget.
        /// </summary>
        /// <param name="typeInfo">The candidate type.</param>
        /// <returns>True if the candidate type represents a widget, otherwise false.</returns>
        public static bool IsWidget(TypeInfo typeInfo)
        {
            if (!typeInfo.IsClass
                || !typeInfo.IsPublic
                || typeInfo.IsAbstract
                || typeInfo.ContainsGenericParameters)
            {
                return false;
            }

            return typeInfo.Name.EndsWith(WidgetSuffix, StringComparison.OrdinalIgnoreCase)
                || typeInfo.GetCustomAttribute<WidgetAttribute>() != null;
        }

 /// <summary>
 /// Determines whether the provided type info is an eligible part.
 /// </summary>
 /// <param name="typeInfo">The type information.</param>
 /// <returns>
 /// <c>true</c> if the type information is an eligible part, otherwise <c>false</c>.
 /// </returns>
 private bool IsEligiblePart(TypeInfo typeInfo)
 {
     return typeInfo.IsClass && !typeInfo.IsAbstract && typeInfo.GetCustomAttribute<ExcludeFromCompositionAttribute>() == null;
 }