FieldAttributes Enumeração

Definição

Especifica os sinalizadores que descrevem os atributos de um campo.Specifies flags that describe the attributes of a field.

Esta enumeração tem um atributo FlagsAttribute que permite uma combinação bit a bit dos seus valores membros.

public enum class FieldAttributes
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum FieldAttributes
type FieldAttributes = 
Public Enum FieldAttributes
Herança
FieldAttributes
Atributos

Campos

Assembly 3

Especifica que o campo pode ser acessado em todo o assembly.Specifies that the field is accessible throughout the assembly.

FamANDAssem 2

Especifica que o campo pode ser acessado somente por subtipos nesse assembly.Specifies that the field is accessible only by subtypes in this assembly.

Family 4

Especifica que o campo pode ser acessado somente por tipos e subtipos.Specifies that the field is accessible only by type and subtypes.

FamORAssem 5

Especifica que o campo pode ser acessado por subtipos em qualquer lugar, bem como em todo este assembly.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.

FieldAccessMask 7

Especifica o nível de acesso de um determinado campo.Specifies the access level of a given field.

HasDefault 32768

Especifica que o campo tem um valor padrão.Specifies that the field has a default value.

HasFieldMarshal 4096

Especifica que o campo tem informações de marshaling.Specifies that the field has marshaling information.

HasFieldRVA 256

Especifica que o campo tem um endereço virtual relativo (RVA).Specifies that the field has a relative virtual address (RVA). O RVA é o local do corpo do método na imagem atual, como um endereço relativo para o início do arquivo de imagem na qual ele está localizado.The RVA is the location of the method body in the current image, as an address relative to the start of the image file in which it is located.

InitOnly 32

Especifica que o campo é inicializado apenas e pode ser definido somente no corpo de um construtor.Specifies that the field is initialized only, and can be set only in the body of a constructor.

Literal 64

Especifica que o valor do campo é uma constante de tempo de compilação (associação estática ou inicial).Specifies that the field's value is a compile-time (static or early bound) constant. Qualquer tentativa de definir inicia um FieldAccessException.Any attempt to set it throws a FieldAccessException.

NotSerialized 128

Especifica que o campo não precisa ser serializado quando o tipo é remoto.Specifies that the field does not have to be serialized when the type is remoted.

PinvokeImpl 8192

Reservado para uso futuro.Reserved for future use.

Private 1

Especifica que o campo pode ser acessado somente por tipo de pai.Specifies that the field is accessible only by the parent type.

PrivateScope 0

Especifica que o campo não pode ser referenciado.Specifies that the field cannot be referenced.

Public 6

Especifica que o campo pode ser acessado por qualquer membro para quem este escopo está visível.Specifies that the field is accessible by any member for whom this scope is visible.

ReservedMask 38144

Reservado.Reserved.

RTSpecialName 1024

Especifica que o common language runtime (APIs internas de metadados) deve verificar a codificação de nome.Specifies that the common language runtime (metadata internal APIs) should check the name encoding.

SpecialName 512

Especifica um método especial, com o nome que descreve como o método é especial.Specifies a special method, with the name describing how the method is special.

Static 16

Especifica que o campo representa o tipo definido ou então é por instância.Specifies that the field represents the defined type, or else it is per-instance.

Exemplos

Neste exemplo, três campos são criados e os FieldAttributes valores são exibidos.In this example, three fields are built and the FieldAttributes values are displayed. Um FieldAttributes valor pode conter mais de um atributo, por exemplo Public , e Literal, como mostrado no terceiro campo.A FieldAttributes value can contain more than one attribute, for example, both Public and Literal, as shown in the third field.

using namespace System;
using namespace System::Reflection;
using namespace System::Security::Permissions;

public ref class Demo
{
private:
    // Make three fields:
    // The first field is private.
    String^ m_field;

    // The second field is public.
public:
    String^ Field;

    // The third field is public and literal. 
    literal String^ FieldC = "String C";

    Demo() { m_field = "String A"; Field = "String B"; }
};

static void DisplayField(Object^ obj, FieldInfo^ f)
{ 
    // Display the field name, value, and attributes.
    //
    Console::WriteLine("{0} = \"{1}\"; attributes: {2}", 
        f->Name, f->GetValue(obj), f->Attributes);
};

void main()
{
    Console::WriteLine ("\nReflection.FieldAttributes");
    Demo^ d = gcnew Demo();

    // Get a Type object for Demo, and a FieldInfo for each of
    // the three fields. Use the FieldInfo to display field
    // name, value for the Demo object in d, and attributes.
    //
    Type^ myType = Demo::typeid;

    FieldInfo^ fiPrivate = myType->GetField("m_field",
        BindingFlags::NonPublic | BindingFlags::Instance);
    DisplayField(d, fiPrivate);

    FieldInfo^ fiPublic = myType->GetField("Field",
        BindingFlags::Public | BindingFlags::Instance);
    DisplayField(d, fiPublic);

    FieldInfo^ fiConstant = myType->GetField("FieldC",
        BindingFlags::Public | BindingFlags::Static);
    DisplayField(d, fiConstant);
}

/* This code example produces the following output:

Reflection.FieldAttributes
m_field = "String A"; attributes: Private
Field = "String B"; attributes: Public
FieldC = "String C"; attributes: Public, Static, Literal, HasDefault
 */
using System;
using System.Reflection;

public class Demo
{
    // Make three fields:
    // The first field is private.
    private string m_field = "String A";

    // The second field is public.
    public string Field = "String B";

    // The third field is public const (hence also literal and static),
    // with a default value.
    public const string FieldC = "String C";
}

public class Myfieldattributes
{
    public static void Main()
    {
        Console.WriteLine ("\nReflection.FieldAttributes");
        Demo d = new Demo();
 
        // Get a Type object for Demo, and a FieldInfo for each of
        // the three fields. Use the FieldInfo to display field
        // name, value for the Demo object in d, and attributes.
        //
        Type myType = typeof(Demo);
        FieldInfo fiPrivate = myType.GetField("m_field",
            BindingFlags.NonPublic | BindingFlags.Instance);
        DisplayField(d, fiPrivate);

        FieldInfo fiPublic = myType.GetField("Field",
            BindingFlags.Public | BindingFlags.Instance);
        DisplayField(d, fiPublic);

        FieldInfo fiConstant = myType.GetField("FieldC",
            BindingFlags.Public | BindingFlags.Static);
        DisplayField(d, fiConstant);
    }

    static void DisplayField(Object obj, FieldInfo f)
    { 
        // Display the field name, value, and attributes.
        //
        Console.WriteLine("{0} = \"{1}\"; attributes: {2}", 
            f.Name, f.GetValue(obj), f.Attributes);
    }
}

/* This code example produces the following output:

Reflection.FieldAttributes
m_field = "String A"; attributes: Private
Field = "String B"; attributes: Public
FieldC = "String C"; attributes: Public, Static, Literal, HasDefault
 */
Imports System.Reflection

Public Class Demo
    ' Declare three fields.
    ' The first field is private.
    Private m_field As String = "String A"

    'The second field is public.
    Public Field As String = "String B"

    ' The third field is public and const, hence also static
    ' and literal with a default value.
    Public Const FieldC As String = "String C"

End Class

Module Module1
    Sub Main()
        ' Create an instance of the Demo class.
        Dim d As New Demo()

        Console.WriteLine(vbCrLf & "Reflection.FieldAttributes")

        ' Get a Type object for Demo, and a FieldInfo for each of
        ' the three fields. Use the FieldInfo to display field
        ' name, value for the Demo object in d, and attributes.
        '
        Dim myType As Type = GetType(Demo)

        Dim fiPrivate As FieldInfo = myType.GetField("m_field", _
            BindingFlags.NonPublic Or BindingFlags.Instance)
        DisplayField(d, fiPrivate)

        Dim fiPublic As FieldInfo = myType.GetField("Field", _
            BindingFlags.Public Or BindingFlags.Instance)
        DisplayField(d, fiPublic)

        Dim fiConstant As FieldInfo = myType.GetField("FieldC", _
            BindingFlags.Public Or BindingFlags.Static)
        DisplayField(d, fiConstant)
    End Sub

    Sub DisplayField(ByVal obj As Object, ByVal f As FieldInfo)

        ' Display the field name, value, and attributes.
        '
        Console.WriteLine("{0} = ""{1}""; attributes: {2}", _
            f.Name, f.GetValue(obj), f.Attributes)
    End Sub

End Module

' This code example produces the following output:
'
'm_field = "String A"; attributes: Private
'Field = "String B"; attributes: Public
'FieldC = "String C"; attributes: Public, Static, Literal, HasDefault

Comentários

FieldAttributesusa o valor de FieldAccessMask para mascarar apenas as partes do valor de atributo que pertencem à acessibilidade.FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. Por exemplo, o código a seguir determina Attributes se o tem o conjunto de bits público.For example, the following code determines if Attributes has the public bit set.

FieldInfo^ fi = obj->GetType()->GetField("field1");

if ((fi->Attributes & FieldAttributes::FieldAccessMask) ==
    FieldAttributes::Public)
{
    Console::WriteLine("{0:s} is public. Value: {1:d}", fi->Name, fi->GetValue(obj));
}
FieldInfo fi = obj.GetType().GetField("field1");

if ((fi.Attributes & FieldAttributes.FieldAccessMask) ==
    FieldAttributes.Public)
{
    Console.WriteLine("{0:s} is public. Value: {1:d}", fi.Name, fi.GetValue(obj));
}
Dim fi As FieldInfo = obj.GetType().GetField("field1")

If (fi.Attributes And FieldAttributes.FieldAccessMask) = _
    FieldAttributes.Public Then
    Console.WriteLine("{0:s} is public. Value: {1:d}", fi.Name, fi.GetValue(obj))
End If

Para obter a FieldAttributes, primeiro obtenha a classe Type.To get the FieldAttributes, first get the class Type. No, obtenha o FieldInfo. TypeFrom the Type, get the FieldInfo. No, obtenha o Attributes. FieldInfoFrom the FieldInfo, get the Attributes.

O valor enumerado é um número que representa a quantidade de bits ou os atributos implementados no campo.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

Aplica-se a