TypeAttributes Énumération

Définition

Espace de noms:

System.Reflection

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

TypeAttributes.cs

Spécifie les attributs de type.

Cette énumération prend en charge une combinaison au niveau du bit de ses valeurs membres.

public enum class TypeAttributes

[System.Flags]
public enum TypeAttributes

[<System.Flags>]
type TypeAttributes = 

Public Enum TypeAttributes

Héritage

Object

ValueType

Enum

TypeAttributes

Attributs

FlagsAttribute

Champs

Nom	Valeur	Description
AnsiClass	0	LPTSTR est interprété comme ANSI.
AutoLayout	0	Spécifie que les champs de classe sont automatiquement disposés par le Common Language Runtime.
Class	0	Spécifie que le type est une classe.
NotPublic	0	Spécifie que la classe n’est pas publique.
Public	1	Spécifie que la classe est publique.
NestedPublic	2	Spécifie que la classe est imbriquée avec une visibilité publique.
NestedPrivate	3	Spécifie que la classe est imbriquée avec une visibilité privée.
NestedFamily	4	Spécifie que la classe est imbriquée avec une visibilité familiale et est donc accessible uniquement par des méthodes de son propre type et de tous les types dérivés.
NestedAssembly	5	Spécifie que la classe est imbriquée avec une visibilité d’assembly et est donc accessible uniquement par des méthodes au sein de son assembly.
NestedFamANDAssem	6	Spécifie que la classe est imbriquée avec une visibilité d’assembly et de famille, et est donc accessible uniquement par des méthodes qui se situent dans l’intersection de sa famille et de son assembly.
NestedFamORAssem	7	Spécifie que la classe est imbriquée avec la visibilité de la famille ou de l’assembly, et est donc accessible uniquement par les méthodes qui se situent dans l’union de sa famille et de son assembly.
VisibilityMask	7	Spécifie les informations de visibilité de type.
SequentialLayout	8	Spécifie que les champs de classe sont disposés de manière séquentielle, dans l’ordre dans lequel les champs ont été émis dans les métadonnées.
ExplicitLayout	16	Spécifie que les champs de classe sont disposés aux décalages spécifiés.
LayoutMask	24	Spécifie les informations de disposition de classe.
ClassSemanticsMask	32	Spécifie les informations sémantiques de classe ; la classe actuelle est contextuelle (sinon agile).
Interface	32	Spécifie que le type est une interface.
Abstract	128	Spécifie que le type est abstrait.
Sealed	256	Spécifie que la classe est concrète et ne peut pas être étendue.
SpecialName	1024	Spécifie que la classe est spéciale d’une manière indiquée par le nom.
RTSpecialName	2048	Le runtime doit vérifier l’encodage de nom.
Import	4096	Spécifie que la classe ou l’interface est importée à partir d’un autre module.
Serializable	8192	Spécifie que la classe peut être sérialisée.
WindowsRuntime	16384	Spécifie un type Windows Runtime.
UnicodeClass	65536	LPTSTR est interprété comme UNICODE.
AutoClass	131072	LPTSTR est interprété automatiquement.
CustomFormatClass	196608	LPSTR est interprété par certains moyens spécifiques à l’implémentation, ce qui inclut la possibilité de lever un NotSupportedException. Non utilisé dans l’implémentation Microsoft du .NET Framework.
StringFormatMask	196608	Permet de récupérer des informations de chaîne pour l’interopérabilité native.
HasSecurity	262144	Le type est associé à la sécurité.
ReservedMask	264192	Attributs réservés à l’utilisation du runtime.
BeforeFieldInit	1048576	Spécifie que l’appel de méthodes statiques du type ne force pas le système à initialiser le type.
CustomFormatMask	12582912	Permet de récupérer des informations d’encodage non standard pour l’interopérabilité native. La signification des valeurs de ces 2 bits n’est pas spécifiée. Non utilisé dans l’implémentation Microsoft du .NET Framework.

Exemples

L’exemple suivant récupère la valeur de la Attributes propriété pour Type les objets qui représentent un certain nombre de types différents, puis détermine si des indicateurs d’attribut individuels ont été définis.

using System;
using System.Reflection;

internal struct S
{
    public int X;
}

public abstract class Example
{
    protected sealed class NestedClass {}

    public interface INested {}

    public static void Main()
    {
        // Create an array of types.
        Type[] types = { typeof(Example), typeof(NestedClass),
                         typeof(INested), typeof(S) };

        foreach (var t in types) 
        {
           Console.WriteLine("Attributes for type {0}:", t.Name);

           TypeAttributes attr = t.Attributes;

           // To test for visibility attributes, you must use the visibility mask.
           TypeAttributes visibility = attr & TypeAttributes.VisibilityMask;
           switch (visibility)
           {
               case TypeAttributes.NotPublic:
                   Console.WriteLine("   ...is not public");
                   break;
               case TypeAttributes.Public:
                   Console.WriteLine("   ...is public");
                   break;
               case TypeAttributes.NestedPublic:
                   Console.WriteLine("   ...is nested and public");
                   break;
               case TypeAttributes.NestedPrivate:
                   Console.WriteLine("   ...is nested and private");
                   break;
               case TypeAttributes.NestedFamANDAssem:
                   Console.WriteLine("   ...is nested, and inheritable only within the assembly" +
                      "\n         (cannot be declared in C#)");
                   break;
               case TypeAttributes.NestedAssembly:
                   Console.WriteLine("   ...is nested and internal");
                   break;
               case TypeAttributes.NestedFamily:
                   Console.WriteLine("   ...is nested and protected");
                   break;
               case TypeAttributes.NestedFamORAssem:
                   Console.WriteLine("   ...is nested and protected internal");
                   break;
           }

           // Use the layout mask to test for layout attributes.
           TypeAttributes layout = attr & TypeAttributes.LayoutMask;
           switch (layout)
           {
               case TypeAttributes.AutoLayout:
                   Console.WriteLine("   ...is AutoLayout");
                   break;
               case TypeAttributes.SequentialLayout:
                   Console.WriteLine("   ...is SequentialLayout");
                   break;
               case TypeAttributes.ExplicitLayout:
                   Console.WriteLine("   ...is ExplicitLayout");
                   break;
           }

           // Use the class semantics mask to test for class semantics attributes.
           TypeAttributes classSemantics = attr & TypeAttributes.ClassSemanticsMask;
           switch (classSemantics)
           {
               case TypeAttributes.Class:
                   if (t.IsValueType)
                   {
                       Console.WriteLine("   ...is a value type");
                   }
                   else
                   {
                       Console.WriteLine("   ...is a class");
                   }
                   break;
               case TypeAttributes.Interface:
                   Console.WriteLine("   ...is an interface");
                   break;
           }

           if ((attr & TypeAttributes.Abstract) != 0)
           {
               Console.WriteLine("   ...is abstract");
           }

           if ((attr & TypeAttributes.Sealed) != 0)
           {
               Console.WriteLine("   ...is sealed");
           }
           
           Console.WriteLine();
       }
    }
}
// The example displays the following output:
// Attributes for type Example:
//    ...is public
//    ...is AutoLayout
//    ...is a class
//    ...is abstract

// Attributes for type NestedClass:
//    ...is nested and protected
//    ...is AutoLayout
//    ...is a class
//    ...is sealed

// Attributes for type INested:
//    ...is nested and public
//    ...is AutoLayout
//    ...is an interface
//    ...is abstract

// Attributes for type S:
//    ...is not public
//    ...is SequentialLayout
//    ...is a value type
//    ...is sealed

Imports System.Reflection

Friend Structure S
    Public X As Integer
End Structure

Public MustInherit Class Example
    Protected NotInheritable Class NestedClass
    End Class

    Public Interface INested
    End Interface

    Public Shared Sub Main()
        ' Create an array of types.
        Dim types() As Type = { GetType(Example), GetType(NestedClass),
                                GetType(INested), GetType(S) }

        For Each t In types
           Console.WriteLine("Attributes for type {0}:", t.Name)

           Dim attr As TypeAttributes = t.Attributes

           ' Use the visibility mask to test for visibility attributes.
           Dim visibility As TypeAttributes = attr And TypeAttributes.VisibilityMask
           Select Case visibility
               Case TypeAttributes.NotPublic:
                   Console.WriteLine("   ...is not Public")
               Case TypeAttributes.Public:
                   Console.WriteLine("   ...is Public")
               Case TypeAttributes.NestedPublic:
                   Console.WriteLine("   ...is nested and Public")
               Case TypeAttributes.NestedPrivate:
                   Console.WriteLine("   ...is nested and Private")
               Case TypeAttributes.NestedFamANDAssem:
                   Console.WriteLine("   ...is nested, and inheritable only within the assembly" & _
                      vbLf & "         (cannot be declared in Visual Basic)")
               Case TypeAttributes.NestedAssembly:
                   Console.WriteLine("   ...is nested and Friend")
               Case TypeAttributes.NestedFamily:
                   Console.WriteLine("   ...is nested and Protected")
               Case TypeAttributes.NestedFamORAssem:
                   Console.WriteLine("   ...is nested and Protected Friend")
           End Select

           ' Use the layout mask to test for layout attributes.
           Dim layout As TypeAttributes = attr And TypeAttributes.LayoutMask
           Select Case layout
               Case TypeAttributes.AutoLayout:
                   Console.WriteLine("   ...is AutoLayout")
               Case TypeAttributes.SequentialLayout:
                   Console.WriteLine("   ...is SequentialLayout")
               Case TypeAttributes.ExplicitLayout:
                   Console.WriteLine("   ...is ExplicitLayout")
           End Select

           ' Use the class semantics mask to test for class semantics attributes.
           Dim classSemantics As TypeAttributes = attr And TypeAttributes.ClassSemanticsMask
           Select Case classSemantics
               Case TypeAttributes.Class:
                   If t.IsValueType Then
                       Console.WriteLine("   ...is a value type")
                   Else
                       Console.WriteLine("   ...is a class")
                   End If
               Case TypeAttributes.Interface:
                   Console.WriteLine("   ...is an interface")
           End Select

           If 0 <> (attr And TypeAttributes.Abstract) Then _
               Console.WriteLine("   ...is MustInherit")

           If 0 <> (attr And TypeAttributes.Sealed) Then _
               Console.WriteLine("   ...is NotInheritable")
           Console.WriteLine()
       Next
    End Sub
End Class
' The example displays the following output:
'       Attributes for type Example:
'          ...is Public
'          ...is AutoLayout
'          ...is a class
'          ...is MustInherit
'
'       Attributes for type NestedClass:
'          ...is nested and Protected
'          ...is AutoLayout
'          ...is a class
'          ...is NotInheritable
'
'       Attributes for type INested:
'          ...is nested and Public
'          ...is AutoLayout
'          ...is an interface
'          ...is MustInherit
'
'       Attributes for type S:
'          ...is not Public
'          ...is SequentialLayout
'          ...is a value type
'          ...is NotInheritable

Remarques

Certains membres de l’énumération TypeAttributes sont des masques qui représentent un ensemble d’attributs mutuellement exclusifs. Par exemple, le VisibilityMask membre inclut les NotPublicmembres , NestedPublicNestedFamilyNestedPrivateNestedAssemblyPublicet NestedFamANDAssemNestedFamORAssem les membres. Étant donné que chaque jeu d’attributs inclut un membre dont la valeur sous-jacente est zéro, vous devez d’abord And la valeur du masque avec la valeur spécifique System.Reflection.TypeAttributes récupérée à partir d’une propriété telle que Type.Attributes. Le tableau suivant répertorie les masques et les membres individuels qu’ils incluent :

Mask	Includes
VisibilityMask	NotPublic Public NestedPublic NestedPrivate NestedFamily NestedAssembly NestedFamANDAssem NestedFamORAssem
Masque de disposition	Superposition automatique SéquentielLayout ExplicitLayout
ClassSemanticsMask	Classe Interface
StringFormatMask	AnsiClass UnicodeClass AutoClass CustomFormatClass
CustomFormatMask	Aucun membre.

Les membres de cette classe d’énumérateur correspondent à l’énumérateur CorTypeAttr tel que défini dans le fichier corhdr.h.