FieldAttributes Énumération
Définition
Spécifie les indicateurs qui décrivent les attributs d'un champ.Specifies flags that describe the attributes of a field.
Cette énumération a un attribut FlagsAttribute qui permet une combinaison au niveau du bit de ses valeurs membres.
public enum class FieldAttributes
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum FieldAttributes
type FieldAttributes =
Public Enum FieldAttributes
- Héritage
- Attributs
Champs
Assembly | 3 | Spécifie que le champ est accessible dans tout l'assembly.Specifies that the field is accessible throughout the assembly. |
FamANDAssem | 2 | Spécifie que le champ est uniquement accessible aux sous-types de l'assembly.Specifies that the field is accessible only by subtypes in this assembly. |
Family | 4 | Spécifie que le champ est accessible aux types et aux sous-types uniquement.Specifies that the field is accessible only by type and subtypes. |
FamORAssem | 5 | Spécifie que le champ est accessible aux sous-types, n'importe où, ainsi que dans la totalité de l'assembly.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly. |
FieldAccessMask | 7 | Spécifie le niveau d'accès d'un champ donné.Specifies the access level of a given field. |
HasDefault | 32768 | Spécifie que le champ a une valeur par défaut.Specifies that the field has a default value. |
HasFieldMarshal | 4096 | Spécifie que le champ comporte des données de marshaling.Specifies that the field has marshaling information. |
HasFieldRVA | 256 | Spécifie que le champ a une adresse virtuelle relative (RVA, Relative Virtual Address).Specifies that the field has a relative virtual address (RVA). 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.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 | Spécifie que le champ est uniquement initialisé et peut être défini uniquement dans le corps d'un constructeur.Specifies that the field is initialized only, and can be set only in the body of a constructor. |
Literal | 64 | Spécifie que la valeur du champ est une constante de compilation (liaison statique ou anticipée).Specifies that the field's value is a compile-time (static or early bound) constant. Toute tentative pour le définir lève un FieldAccessException.Any attempt to set it throws a FieldAccessException. |
NotSerialized | 128 | Spécifie qu'il n'est pas nécessaire de sérialiser le champ dans le cas d'un type distant.Specifies that the field does not have to be serialized when the type is remoted. |
PinvokeImpl | 8192 | Réservé à un usage ultérieur.Reserved for future use. |
Private | 1 | Spécifie que seul le type parent peut accéder au champ.Specifies that the field is accessible only by the parent type. |
PrivateScope | 0 | Spécifie que le champ ne peut pas être référencé.Specifies that the field cannot be referenced. |
Public | 6 | Spécifie que le champ est accessible à tout membre pour lequel cette portée est visible.Specifies that the field is accessible by any member for whom this scope is visible. |
ReservedMask | 38144 | Réservé.Reserved. |
RTSpecialName | 1024 | Spécifie que le Common Language Runtime (API internes de métadonnées) doit vérifier l'encodage des noms.Specifies that the common language runtime (metadata internal APIs) should check the name encoding. |
SpecialName | 512 | Définit une méthode particulière dont la spécificité est décrite par le nom.Specifies a special method, with the name describing how the method is special. |
Static | 16 | Spécifie que le champ représente le type défini ou qu'il est par instance.Specifies that the field represents the defined type, or else it is per-instance. |
Exemples
Dans cet exemple, trois champs sont générés et FieldAttributes
les valeurs sont affichées.In this example, three fields are built and the FieldAttributes
values are displayed. Une FieldAttributes
valeur peut contenir plusieurs attributs, par exemple Public
, et Literal
, comme indiqué dans le troisième champ.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
Remarques
FieldAttributes
utilise la valeur de FieldAccessMask
pour masquer uniquement les parties de la valeur d’attribut qui se rapportent à l’accessibilité.FieldAttributes
uses the value from FieldAccessMask
to mask off only the parts of the attribute value that pertain to the accessibility. Par exemple, le code suivant détermine si Attributes
a le bit public défini.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
Pour récupérer le FieldAttributes
, commencez par récupérer la Type
classe.To get the FieldAttributes
, first get the class Type
. À partir Type
de la, FieldInfo
récupérez le.From the Type
, get the FieldInfo
. À partir FieldInfo
de la, Attributes
récupérez le.From the FieldInfo
, get the Attributes
.
La valeur énumérée est un nombre qui représente l’opération de bits OR des attributs implémentés sur le champ.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.