TypeAttributes Enumerazione

Definizione

Specifica gli attributi del tipo.Specifies type attributes.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class TypeAttributes
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum TypeAttributes
type TypeAttributes = 
Public Enum TypeAttributes
Ereditarietà
TypeAttributes
Attributi

Campi

Abstract 128

Specifica che il tipo è astratto.Specifies that the type is abstract.

AnsiClass 0

LPTSTR è interpretato come ANSI.LPTSTR is interpreted as ANSI.

AutoClass 131072

LPTSTR è interpretato automaticamente.LPTSTR is interpreted automatically.

AutoLayout 0

Specifica che i campi della classe sono posizionati automaticamente da Common Language Runtime.Specifies that class fields are automatically laid out by the common language runtime.

BeforeFieldInit 1048576

Specifica che la chiamata a metodi static del tipo non determina l'inizializzazione del tipo da parte del sistema.Specifies that calling static methods of the type does not force the system to initialize the type.

Class 0

Specifica che il tipo è una classe.Specifies that the type is a class.

ClassSemanticsMask 32

Specifica le informazioni relative alla semantica della classe; la classe corrente è ricca di contesti (ovvero agile).Specifies class semantics information; the current class is contextful (else agile).

CustomFormatClass 196608

LPSTR viene interpretato da alcuni mezzi specifici dell'implementazione; ciò include la possibilità di generare un'eccezione NotSupportedException.LPSTR is interpreted by some implementation-specific means, which includes the possibility of throwing a NotSupportedException. Non utilizzato nell'implementazione Microsoft di .NET Framework.NET Framework.Not used in the Microsoft implementation of the .NET Framework.NET Framework.

CustomFormatMask 12582912

Utilizzato per recuperare informazioni di codifica non standard per l'interoperabilità nativa.Used to retrieve non-standard encoding information for native interop. Il significato dei valori di questi 2 bit non è specificato.The meaning of the values of these 2 bits is unspecified. Non utilizzato nell'implementazione Microsoft di .NET Framework.NET Framework.Not used in the Microsoft implementation of the .NET Framework.NET Framework.

ExplicitLayout 16

Specifica che i campi della classe sono posizionati in corrispondenza degli offset specificati.Specifies that class fields are laid out at the specified offsets.

HasSecurity 262144

Il tipo dispone di sicurezza associata.Type has security associate with it.

Import 4096

Specifica che la classe o l'interfaccia viene importata da un altro modulo.Specifies that the class or interface is imported from another module.

Interface 32

Specifica che il tipo è un'interfaccia.Specifies that the type is an interface.

LayoutMask 24

Specifica le informazioni di layout della classe.Specifies class layout information.

NestedAssembly 5

Specifica che la classe è annidata e visibile soltanto all'interno dell'assembly, pertanto accessibile solo dai metodi all'interno del corrispondente assembly.Specifies that the class is nested with assembly visibility, and is thus accessible only by methods within its assembly.

NestedFamANDAssem 6

Specifica che la classe è annidata e visibile soltanto all'interno dell'assembly e della famiglia, pertanto accessibile solo dai metodi all'interno dell'intersezione tra l'assembly e la famiglia.Specifies that the class is nested with assembly and family visibility, and is thus accessible only by methods lying in the intersection of its family and assembly.

NestedFamily 4

Specifica che la classe è annidata e visibile a livello di famiglia, pertanto accessibile solo dai metodi all'interno del proprio tipo e degli eventuali tipi derivati.Specifies that the class is nested with family visibility, and is thus accessible only by methods within its own type and any derived types.

NestedFamORAssem 7

Specifica che la classe è annidata e visibile soltanto all'interno dell'assembly o della famiglia, pertanto accessibile solo dai metodi all'interno dell'unione tra l'assembly e la famiglia.Specifies that the class is nested with family or assembly visibility, and is thus accessible only by methods lying in the union of its family and assembly.

NestedPrivate 3

Specifica che la classe è annidata e con visibilità privata.Specifies that the class is nested with private visibility.

NestedPublic 2

Specifica che la classe è annidata e con visibilità pubblica.Specifies that the class is nested with public visibility.

NotPublic 0

Specifica che la classe non è pubblica.Specifies that the class is not public.

Public 1

Specifica che la classe è pubblica.Specifies that the class is public.

ReservedMask 264192

Attributi riservati per l'utilizzo di runtime.Attributes reserved for runtime use.

RTSpecialName 2048

Il runtime deve controllare la codifica dei nomi.Runtime should check name encoding.

Sealed 256

Specifica che la classe è concreta e non può essere estesa.Specifies that the class is concrete and cannot be extended.

SequentialLayout 8

Specifica che i campi della classe sono posizionati in modo sequenziale, nell'ordine in cui sono stati emessi ai metadati.Specifies that class fields are laid out sequentially, in the order that the fields were emitted to the metadata.

Serializable 8192

Specifica che è possibile serializzare la classe.Specifies that the class can be serialized.

SpecialName 1024

Specifica che si tratta di una classe speciale nel modo descritto dal nome.Specifies that the class is special in a way denoted by the name.

StringFormatMask 196608

Utilizzato per recuperare informazioni di stringa per l'interoperabilità nativa.Used to retrieve string information for native interoperability.

UnicodeClass 65536

LPTSTR è interpretato come UNICODE.LPTSTR is interpreted as UNICODE.

VisibilityMask 7

Specifica le informazioni di visibilità del tipo.Specifies type visibility information.

WindowsRuntime 16384

Specifica un tipo Windows RuntimeWindows Runtime.Specifies a Windows RuntimeWindows Runtime type.

Esempi

Nell'esempio seguente viene recuperato il valore della Attributes proprietà per Type gli oggetti che rappresentano un numero di tipi diversi e quindi viene determinato se sono stati impostati singoli flag di attributo.The following example retrieves the value of the Attributes property for Type objects that represent a number of different types, and then determines whether individual attribute flags have been set.

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

Commenti

Alcuni dei membri dell' TypeAttributes enumerazione sono maschere che rappresentano un set di attributi che si escludono a vicenda.Some of the members of the TypeAttributes enumeration are masks that represent a set of mutually exclusive attributes. VisibilityMask Il membro, ad esempio, include NotPublici Publicmembri, NestedPrivate, NestedFamily NestedPublic, NestedAssembly, NestedFamANDAssem,, e NestedFamORAssem .For example, the VisibilityMask member includes the NotPublic, Public, NestedPublic, NestedPrivate, NestedFamily, NestedAssembly, NestedFamANDAssem, and NestedFamORAssem members. Poiché ogni set di attributi include un membro il cui valore sottostante è zero, è And necessario innanzitutto il valore della maschera con il System.Reflection.TypeAttributes valore specifico recuperato Type.Attributesda una proprietà, ad esempio.Because each attribute set includes a member whose underlying value is zero, you should first And the value of the mask with the specific System.Reflection.TypeAttributes value retrieved from a property such as Type.Attributes. Nella tabella seguente sono elencate le maschere e i singoli membri che includono:The following table lists the masks and the individual members that they include:

MascheraMask IncludeIncludes
VisibilityMaskVisibilityMask NotPublicNotPublic
PublicPublic
NestedPublicNestedPublic
NestedPrivateNestedPrivate
NestedFamilyNestedFamily
NestedAssemblyNestedAssembly
NestedFamANDAssemNestedFamANDAssem
NestedFamORAssemNestedFamORAssem
LayoutMaskLayoutMask AutoLayoutAutoLayout
SequentialLayoutSequentialLayout
ExplicitLayoutExplicitLayout
ClassSemanticsMaskClassSemanticsMask ClasseClass
InterfacciaInterface
StringFormatMaskStringFormatMask AnsiClassAnsiClass
UnicodeClassUnicodeClass
AutoClassAutoClass
CustomFormatClassCustomFormatClass
CustomFormatMaskCustomFormatMask Nessun membro.No members.

I membri di questa classe enumeratore corrispondono all'enumeratore CorTypeAttr, come definito nel file corhdr. h.The members of this enumerator class match the CorTypeAttr enumerator as defined in the corhdr.h file.

Si applica a