FieldAttributes FieldAttributes FieldAttributes FieldAttributes Enum

Definition

Gibt Flags an, die die Attribute eines Felds beschreiben.Specifies flags that describe the attributes of a field.

Diese Enumeration weist ein FlagsAttribute-Attribut auf, die eine bitweise Kombination der Memberwerte zulässt.

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

Felder

Assembly Assembly Assembly Assembly 3

Gibt an, dass auf das Feld von der gesamten Assembly aus zugegriffen werden kann.Specifies that the field is accessible throughout the assembly.

FamANDAssem FamANDAssem FamANDAssem FamANDAssem 2

Gibt an, dass auf das Feld nur von Untertypen in dieser Assembly zugegriffen werden kann.Specifies that the field is accessible only by subtypes in this assembly.

Family Family Family Family 4

Gibt an, dass auf das Feld nur von Typen und Untertypen zugegriffen werden kann.Specifies that the field is accessible only by type and subtypes.

FamORAssem FamORAssem FamORAssem FamORAssem 5

Gibt an, dass auf das Feld sowohl von Untertypen von einem beliebigen Ort als auch aus der gesamten Assembly zugegriffen werden kann.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.

FieldAccessMask FieldAccessMask FieldAccessMask FieldAccessMask 7

Gibt die Zugriffsebene für ein angegebenes Feld an.Specifies the access level of a given field.

HasDefault HasDefault HasDefault HasDefault 32768

Gibt an, dass das Feld einen Standardwert besitzt.Specifies that the field has a default value.

HasFieldMarshal HasFieldMarshal HasFieldMarshal HasFieldMarshal 4096

Gibt an, dass das Feld über Marshallinginformationen verfügt.Specifies that the field has marshaling information.

HasFieldRVA HasFieldRVA HasFieldRVA HasFieldRVA 256

Gibt an, dass das Feld eine RVA (relative virtuelle Adresse) besitzt.Specifies that the field has a relative virtual address (RVA). Die RVA bezeichnet die Position des Methodenrumpfes innerhalb des aktuellen Bilds als Adresse relativ zum Beginn der Bilddatei, in der er sich befindet.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

Gibt an, dass das Feld nur im Text eines Konstruktors initialisiert und festgelegt werden kann.Specifies that the field is initialized only, and can be set only in the body of a constructor.

Literal Literal Literal Literal 64

Gibt an, dass es sich bei dem Feldwert um eine Kompilierzeitkonstante (statisch oder früh gebunden) handelt.Specifies that the field's value is a compile-time (static or early bound) constant. Jeder Versuch des Festlegens löst eine FieldAccessException aus.Any attempt to set it throws a FieldAccessException.

NotSerialized NotSerialized NotSerialized NotSerialized 128

Gibt an, dass das Feld nicht serialisiert werden muss, wenn der Typ remote übergeben wird.Specifies that the field does not have to be serialized when the type is remoted.

PinvokeImpl PinvokeImpl PinvokeImpl PinvokeImpl 8192

Für zukünftige Verwendung reserviert.Reserved for future use.

Private Private Private Private 1

Gibt an, dass der Zugriff auf das Feld auf den übergeordneten Typ beschränkt ist.Specifies that the field is accessible only by the parent type.

PrivateScope PrivateScope PrivateScope PrivateScope 0

Gibt an, dass auf das Feld nicht verwiesen werden kann.Specifies that the field cannot be referenced.

Public Public Public Public 6

Gibt an, dass auf das Feld alle Member zugreifen können, für die dieser Gültigkeitsbereich sichtbar ist.Specifies that the field is accessible by any member for whom this scope is visible.

ReservedMask ReservedMask ReservedMask ReservedMask 38144

Reserviert.Reserved.

RTSpecialName RTSpecialName RTSpecialName RTSpecialName 1024

Gibt an, dass die Common Language Runtime (interne APIs für Metadaten) die Namenscodierung überprüfen soll.Specifies that the common language runtime (metadata internal APIs) should check the name encoding.

SpecialName SpecialName SpecialName SpecialName 512

Gibt eine spezielle Methode an, wobei der Name die Besonderheit der Methode beschreibt.Specifies a special method, with the name describing how the method is special.

Static Static Static Static 16

Gibt an, dass das Feld den definierten Typ darstellt oder ansonsten instanzspezifisch ist.Specifies that the field represents the defined type, or else it is per-instance.

Beispiele

In diesem Beispiel werden drei Felder erstellt und die FieldAttributes Werte werden angezeigt.In this example, three fields are built and the FieldAttributes values are displayed. Ein FieldAttributes Wert darf höchstens ein Attribut, z. B. Public und Literal, wie im dritten Feld dargestellt.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

Hinweise

FieldAttributes verwendet den Wert von FieldAccessMask zum Maskieren nur die Teile der Wert des Attributs ein, die den Zugriff auf betreffen.FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. Der folgende Code beispielsweise bestimmt, ob Attributes verfügt über die öffentliche-Bit festgelegt ist.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

Zum Abrufen der FieldAttributes, rufen Sie zunächst die Klasse Type.To get the FieldAttributes, first get the class Type. Von der Type, erhalten die FieldInfo.From the Type, get the FieldInfo. Von der FieldInfo, erhalten die Attributes.From the FieldInfo, get the Attributes.

Der Enumerationswert ist eine Zahl, die das bitweise OR der Attribute für das Feld implementiert.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

Gilt für: