FieldAttributes FieldAttributes FieldAttributes FieldAttributes Enum

Definizione

Specifica i flag che descrivono gli attributi di un campo.Specifies flags that describe the attributes of a field.

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

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

Campi

Assembly Assembly Assembly Assembly 3

Specifica che il campo è accessibile nell'assembly.Specifies that the field is accessible throughout the assembly.

FamANDAssem FamANDAssem FamANDAssem FamANDAssem 2

Specifica che il campo è accessibile solo dai sottotipi di questo assembly.Specifies that the field is accessible only by subtypes in this assembly.

Family Family Family Family 4

Specifica che il campo è accessibile solo dal tipo e dai sottotipi.Specifies that the field is accessible only by type and subtypes.

FamORAssem FamORAssem FamORAssem FamORAssem 5

Specifica che il campo è accessibile dai sottotipi in qualsiasi posizione e in questo assembly.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.

FieldAccessMask FieldAccessMask FieldAccessMask FieldAccessMask 7

Specifica il livello di accesso di un determinato campo.Specifies the access level of a given field.

HasDefault HasDefault HasDefault HasDefault 32768

Specifica che il campo ha un valore predefinito.Specifies that the field has a default value.

HasFieldMarshal HasFieldMarshal HasFieldMarshal HasFieldMarshal 4096

Specifica che il campo dispone di informazioni di marshalling.Specifies that the field has marshaling information.

HasFieldRVA HasFieldRVA HasFieldRVA HasFieldRVA 256

Specifica che il campo ha un indirizzo virtuale relativo (RVA, Relative Virtual Address).Specifies that the field has a relative virtual address (RVA). L'RVA è il percorso del corpo del metodo nell'immagine corrente, come un indirizzo relativo all'inizio del file di immagine in cui si trova.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

Specifica che il campo viene solo inizializzato e può essere impostato solo nel corpo di un costruttore.Specifies that the field is initialized only, and can be set only in the body of a constructor.

Literal Literal Literal Literal 64

Specifica che il valore del campo è una costante (statica o associata) della fase di compilazione.Specifies that the field's value is a compile-time (static or early bound) constant. Qualsiasi tentativo di impostare tale elemento genera un'eccezione FieldAccessException.Any attempt to set it throws a FieldAccessException.

NotSerialized NotSerialized NotSerialized NotSerialized 128

Specifica che il campo non deve essere serializzato quando il tipo è remoto.Specifies that the field does not have to be serialized when the type is remoted.

PinvokeImpl PinvokeImpl PinvokeImpl PinvokeImpl 8192

Riservato per usi futuri.Reserved for future use.

Private Private Private Private 1

Specifica che il campo è accessibile solo dal tipo padre.Specifies that the field is accessible only by the parent type.

PrivateScope PrivateScope PrivateScope PrivateScope 0

Specifica che non è possibile fare riferimento al campo.Specifies that the field cannot be referenced.

Public Public Public Public 6

Specifica che il campo è accessibile da qualsiasi membro per il quale è visibile questo ambito.Specifies that the field is accessible by any member for whom this scope is visible.

ReservedMask ReservedMask ReservedMask ReservedMask 38144

Riservato.Reserved.

RTSpecialName RTSpecialName RTSpecialName RTSpecialName 1024

Specifica che Common Language Runtime (API interne dei metadati) deve controllare la codifica dei nomi.Specifies that the common language runtime (metadata internal APIs) should check the name encoding.

SpecialName SpecialName SpecialName SpecialName 512

Specifica un metodo speciale, la cui caratteristica è indicata dal nome.Specifies a special method, with the name describing how the method is special.

Static Static Static Static 16

Specifica che il campo rappresenta il tipo definito, altrimenti è per istanza.Specifies that the field represents the defined type, or else it is per-instance.

Esempi

In questo esempio vengono compilati tre campi e FieldAttributes vengono visualizzati i valori.In this example, three fields are built and the FieldAttributes values are displayed. Un FieldAttributes valore può contenere più di un attributo, ad esempio Public , e Literal, come illustrato nel terzo 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

Commenti

FieldAttributesUsa il valore FieldAccessMask di per mascherare solo le parti del valore dell'attributo che riguardano l'accessibilità.FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. Il codice seguente, ad esempio, determina Attributes se dispone del bit pubblico impostato.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

Per ottenere FieldAttributes, ottenere prima di tutto la Typeclasse.To get the FieldAttributes, first get the class Type. Type DaFieldInfoottenere.From the Type, get the FieldInfo. FieldInfo DaAttributesottenere.From the FieldInfo, get the Attributes.

Il valore enumerato è un numero che rappresenta l'OR bit per bit degli attributi implementati nel campo.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

Si applica a