FieldAttributes FieldAttributes FieldAttributes FieldAttributes Enum

Definición

Especifica los marcadores que describen los atributos de un campo.Specifies flags that describe the attributes of a field.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

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

Campos

Assembly Assembly Assembly Assembly 3

Especifica que se puede obtener acceso al campo en todo el ensamblado.Specifies that the field is accessible throughout the assembly.

FamANDAssem FamANDAssem FamANDAssem FamANDAssem 2

Especifica que sólo los subtipos de este ensamblado pueden obtener acceso al campo en cuestión.Specifies that the field is accessible only by subtypes in this assembly.

Family Family Family Family 4

Especifica que sólo se puede obtener acceso al campo mediante tipos y subtipos.Specifies that the field is accessible only by type and subtypes.

FamORAssem FamORAssem FamORAssem FamORAssem 5

Especifica que se puede obtener acceso al campo mediante subtipos en cualquier parte, así como en todo el ensamblado.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.

FieldAccessMask FieldAccessMask FieldAccessMask FieldAccessMask 7

Especifica el nivel de acceso de un campo dado.Specifies the access level of a given field.

HasDefault HasDefault HasDefault HasDefault 32768

Especifica que el campo tiene un valor predeterminado.Specifies that the field has a default value.

HasFieldMarshal HasFieldMarshal HasFieldMarshal HasFieldMarshal 4096

Especifica que el campo contiene información de cálculo de referencias.Specifies that the field has marshaling information.

HasFieldRVA HasFieldRVA HasFieldRVA HasFieldRVA 256

Especifica que el campo tiene una dirección relativa virtual (RVA).Specifies that the field has a relative virtual address (RVA). La RVA es la ubicación del cuerpo del método que se encuentra en la imagen principal, como por ejemplo, una dirección relativa al principio del archivo de imagen donde se encuentra.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 InitOnly InitOnly InitOnly 32

Especifica que solo se inicializa el campo y solo se puede establecer en el cuerpo de un constructor.Specifies that the field is initialized only, and can be set only in the body of a constructor.

Literal Literal Literal Literal 64

Especifica que el valor del campo es una constante (estática o de enlace en tiempo de diseño) en tiempo de compilación.Specifies that the field's value is a compile-time (static or early bound) constant. Cualquier intento de establecerlo produce una FieldAccessException.Any attempt to set it throws a FieldAccessException.

NotSerialized NotSerialized NotSerialized NotSerialized 128

Especifica que no es necesario serializar el campo cuando el tipo tiene acceso remoto.Specifies that the field does not have to be serialized when the type is remoted.

PinvokeImpl PinvokeImpl PinvokeImpl PinvokeImpl 8192

Reservado para un uso futuro.Reserved for future use.

Private Private Private Private 1

Especifica que sólo se puede obtener acceso al campo mediante los tipos principales.Specifies that the field is accessible only by the parent type.

PrivateScope PrivateScope PrivateScope PrivateScope 0

Indica que no se pueden crear referencias al campo.Specifies that the field cannot be referenced.

Public Public Public Public 6

Especifica que cualquier miembro, para el cual este ámbito sea visible, puede obtener acceso al campo.Specifies that the field is accessible by any member for whom this scope is visible.

ReservedMask ReservedMask ReservedMask ReservedMask 38144

Reservado.Reserved.

RTSpecialName RTSpecialName RTSpecialName RTSpecialName 1024

Especifica que Common Language Runtime (API de metadatos internas) debe comprobar la codificación de nombres.Specifies that the common language runtime (metadata internal APIs) should check the name encoding.

SpecialName SpecialName SpecialName SpecialName 512

Especifica un método especial y su nombre describe en qué sentido es especial dicho método.Specifies a special method, with the name describing how the method is special.

Static Static Static Static 16

Especifica que el campo representa el tipo definido, o bien es un ejemplo.Specifies that the field represents the defined type, or else it is per-instance.

Ejemplos

En este ejemplo, se generan tres campos y FieldAttributes se muestran los valores.In this example, three fields are built and the FieldAttributes values are displayed. Un FieldAttributes valor puede contener más de un atributo, por ejemplo, ambos Public y Literal, tal y como se muestra en el tercer 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
Imports System.Reflection
Imports Microsoft.VisualBasic

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

Comentarios

FieldAttributes usa el valor de FieldAccessMask para enmascarar sólo las partes del valor del atributo que corresponden a la accesibilidad.FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. Por ejemplo, el código siguiente determina si Attributes tiene el bit público conjunto.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 obtener el FieldAttributes, obtenga primero la clase Type.To get the FieldAttributes, first get the class Type. Desde el Type, obtener el FieldInfo.From the Type, get the FieldInfo. Desde el FieldInfo, obtener el Attributes.From the FieldInfo, get the Attributes.

El valor enumerado es un número que representa la operación OR bit a bit de los atributos implementados en el campo.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

Se aplica a