FieldAttributes Enumeration

Definition

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Gibt Flags an, welche die Attribute eines Felds beschreiben.

Diese Enumeration unterstützt eine bitweise Kombination ihrer Memberwerte.

public enum class FieldAttributes

[System.Flags]
public enum FieldAttributes

[<System.Flags>]
type FieldAttributes = 

Public Enum FieldAttributes

Vererbung

Object

ValueType

Enum

FieldAttributes

Attribute

FlagsAttribute

Felder

Assembly	3	Gibt an, dass auf das Feld von der gesamten Assembly aus zugegriffen werden kann.
FamANDAssem	2	Gibt an, dass auf das Feld nur von Untertypen in dieser Assembly zugegriffen werden kann.
Family	4	Gibt an, dass auf das Feld nur von Typen und Untertypen zugegriffen werden kann.
FamORAssem	5	Gibt an, dass auf das Feld sowohl von Untertypen von einem beliebigen Ort als auch aus der gesamten Assembly zugegriffen werden kann.
FieldAccessMask	7	Gibt die Zugriffsebene für ein angegebenes Feld an.
HasDefault	32768	Gibt an, dass das Feld einen Standardwert besitzt.
HasFieldMarshal	4096	Gibt an, dass das Feld über Marshallinginformationen verfügt.
HasFieldRVA	256	Gibt an, dass das Feld eine RVA (relative virtuelle Adresse) besitzt. Die RVA bezeichnet die Position des Methodenrumpfes innerhalb des aktuellen Bilds als Adresse relativ zum Beginn der Bilddatei, in der er sich befindet.
InitOnly	32	Gibt an, dass das Feld nur im Text eines Konstruktors initialisiert und festgelegt werden kann.
Literal	64	Gibt an, dass es sich bei dem Feldwert um eine Kompilierzeitkonstante (statisch oder früh gebunden) handelt. Jeder Versuch des Festlegens löst eine FieldAccessException aus.
NotSerialized	128	Gibt an, dass das Feld nicht serialisiert werden muss, wenn der Typ remote übergeben wird.
PinvokeImpl	8192	Für zukünftige Verwendung reserviert.
Private	1	Gibt an, dass der Zugriff auf das Feld auf den übergeordneten Typ beschränkt ist.
PrivateScope	0	Gibt an, dass auf das Feld nicht verwiesen werden kann.
Public	6	Gibt an, dass auf das Feld alle Member zugreifen können, für die dieser Gültigkeitsbereich sichtbar ist.
ReservedMask	38144	Reserviert.
RTSpecialName	1024	Gibt an, dass die Common Language Runtime (interne APIs für Metadaten) die Namenscodierung überprüfen soll.
SpecialName	512	Gibt eine spezielle Methode an, wobei der Name die Besonderheit der Methode beschreibt.
Static	16	Gibt an, dass das Feld den definierten Typ darstellt oder ansonsten instanzspezifisch ist.

Beispiele

In diesem Beispiel werden drei Felder erstellt, und die FieldAttributes Werte werden angezeigt. Ein FieldAttributes Wert kann mehr als ein Attribut enthalten, z. B. sowohl als Literalauch Public , wie im dritten Feld dargestellt.

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

Hinweise

FieldAttributes verwendet den Wert von FieldAccessMask , um nur die Teile des Attributwerts zu maskieren, die sich auf die Barrierefreiheit beziehen. Der folgende Code bestimmt beispielsweise, ob Attributes das öffentliche Bit festgelegt ist.

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

Um die FieldAttributesabzurufen, rufen Sie zuerst die -Klasse Typeab. Rufen Sie FieldInfovon abType. Rufen Sie Attributesvon abFieldInfo.

Der aufgezählte Wert ist eine Zahl, die das bitweise OR der attribute darstellt, die im Feld implementiert sind.