FieldAttributes Énumération

Référence

Définition

Espace de noms:: System.Reflection

Assembly:: System.Reflection.Primitives.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Spécifie les indicateurs qui décrivent les attributs d'un champ.

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

public enum class FieldAttributes

[System.Flags]
public enum FieldAttributes

[System.Flags]
[System.Serializable]
public enum FieldAttributes

[System.Flags]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum FieldAttributes

[<System.Flags>]
type FieldAttributes =

[<System.Flags>]
[<System.Serializable>]
type FieldAttributes =

[<System.Flags>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FieldAttributes =

Public Enum FieldAttributes

Héritage: Object

ValueType

Enum
FieldAttributes

Attributs: FlagsAttribute SerializableAttribute ComVisibleAttribute

Champs

Assembly	3	Spécifie que le champ est accessible dans tout l'assembly.
FamANDAssem	2	Spécifie que le champ est uniquement accessible aux sous-types de l'assembly.
Family	4	Spécifie que le champ est accessible aux types et aux sous-types uniquement.
FamORAssem	5	Spécifie que le champ est accessible aux sous-types, n'importe où, ainsi que dans la totalité de l'assembly.
FieldAccessMask	7	Spécifie le niveau d'accès d'un champ donné.
HasDefault	32768	Spécifie que le champ a une valeur par défaut.
HasFieldMarshal	4096	Spécifie que le champ comporte des données de marshaling.
HasFieldRVA	256	Spécifie que le champ a une adresse virtuelle relative (RVA, Relative Virtual Address). L'adresse RVA correspond à l'emplacement du corps de la méthode dans l'image actuelle, sous forme d'une adresse qui est fonction du début du fichier image dans laquelle elle se trouve.
InitOnly	32	Spécifie que le champ est uniquement initialisé et peut être défini uniquement dans le corps d'un constructeur.
Literal	64	Spécifie que la valeur du champ est une constante de compilation (liaison statique ou anticipée). Toute tentative pour le définir lève un FieldAccessException.
NotSerialized	128	Spécifie qu'il n'est pas nécessaire de sérialiser le champ dans le cas d'un type distant.
PinvokeImpl	8192	Réservé à un usage ultérieur.
Private	1	Spécifie que seul le type parent peut accéder au champ.
PrivateScope	0	Spécifie que le champ ne peut pas être référencé.
Public	6	Spécifie que le champ est accessible à tout membre pour lequel cette portée est visible.
ReservedMask	38144	Réservé.
RTSpecialName	1024	Spécifie que le Common Language Runtime (API internes de métadonnées) doit vérifier l'encodage des noms.
SpecialName	512	Définit une méthode particulière dont la spécificité est décrite par le nom.
Static	16	Spécifie que le champ représente le type défini ou qu'il est par instance.

Exemples

Dans cet exemple, trois champs sont générés et les FieldAttributes valeurs sont affichées. Une FieldAttributes valeur peut contenir plusieurs attributs, par exemple, Public et Literal, comme indiqué dans le troisième champ.

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

Remarques

FieldAttributes utilise la valeur de FieldAccessMask pour masquer uniquement les parties de la valeur d’attribut qui se rapportent à l’accessibilité. Par exemple, le code suivant détermine si Attributes a le bit public défini.

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

Pour obtenir le FieldAttributes, commencez par obtenir la classe Type. À partir de Type, obtenez le FieldInfo. À partir de FieldInfo, obtenez le Attributes.

La valeur énumérée est un nombre représentant le ou au niveau du bit des attributs implémentés sur le champ.

S’applique à