FieldAttributes-Enumeration

Artikel
08/20/2007

Gibt Flags an, die die Attribute eines Felds beschreiben.

Diese Enumeration verfügt über ein FlagsAttribute -Attribut, das die bitweise Kombination der Memberwerte zulässt.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<FlagsAttribute> _
<ComVisibleAttribute(True)> _
Public Enumeration FieldAttributes
'Usage
Dim instance As FieldAttributes

[SerializableAttribute] 
[FlagsAttribute] 
[ComVisibleAttribute(true)] 
public enum FieldAttributes

[SerializableAttribute] 
[FlagsAttribute] 
[ComVisibleAttribute(true)] 
public enum class FieldAttributes

/** @attribute SerializableAttribute() */ 
/** @attribute FlagsAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum FieldAttributes

SerializableAttribute 
FlagsAttribute 
ComVisibleAttribute(true) 
public enum FieldAttributes

Member

	Membername	Beschreibung
	Assembly	Gibt an, dass auf das Feld von der gesamten Assembly aus zugegriffen werden kann.
	FamANDAssem	Gibt an, dass auf das Feld nur von Untertypen in dieser Assembly zugegriffen werden kann.
	Family	Gibt an, dass auf das Feld nur von Typen und Untertypen zugegriffen werden kann.
	FamORAssem	Gibt an, dass auf das Feld sowohl von Untertypen von einem beliebigen Ort wie auch aus der gesamten Assembly zugegriffen werden kann.
	FieldAccessMask	Gibt die Zugriffsebene für ein angegebenes Feld an.
	HasDefault	Gibt an, dass das Feld einen Standardwert besitzt.
	HasFieldMarshal	Gibt an, dass das Feld über Marshallinginformationen verfügt.
	HasFieldRVA	Gibt an, dass das Feld eine RVA (relative virtuelle Adresse) besitzt. Die RVA bezeichnet die Position des Methodenrumpfes innerhalb des aktuellen Bildes als Adresse relativ zum Beginn der Bilddatei, in der er sich befindet.
	InitOnly	Gibt an, dass das Feld lediglich initialisiert wird. Nach der Initialisierung ist kein Schreibzugriff möglich.
	Literal	Gibt an, dass es sich bei dem Feldwert um eine Kompilierzeitkonstante (statisch oder früh gebunden) handelt. Kein Set-Accessor.
	NotSerialized	Gibt an, dass das Feld nicht serialisiert werden muss, wenn der Typ remote übergeben wird.
	PinvokeImpl	Für zukünftige Verwendung reserviert.
	Private	Gibt an, dass der Zugriff auf das Feld auf den übergeordneten Typ beschränkt ist.
	PrivateScope	Gibt an, dass auf das Feld nicht verwiesen werden kann.
	Public	Gibt an, dass auf das Feld alle Member zugreifen können, für die dieser Gültigkeitsbereich sichtbar ist.
	ReservedMask	Reserviert.
	RTSpecialName	Gibt an, dass die Common Language Runtime (interne APIs für Metadaten) die Namenscodierung überprüfen soll.
	SpecialName	Gibt eine spezielle Methode an, wobei der Name die Besonderheit der Methode beschreibt.
	Static	Gibt an, dass das Feld den definierten Typ darstellt oder ansonsten instanzspezifisch ist.

Hinweise

FieldAttributes verwendet den Wert von FieldAccessMask zum Maskieren nur der Teile des Attributwerts, die den Zugriff betreffen. Im folgenden Codebeispiel wird bestimmt, ob für Attributes das Public-Bit festgelegt ist:

If (Attributes And FieldAttributes.FieldAccessMask) = _
    FieldAttributes.Public Then

if ((Attributes & FieldAttributes.FieldAccessMask) == 
    FieldAttributes.Public)

Um FieldAttributes abzurufen, rufen Sie zunächst den Type der Klasse ab. Über Type rufen Sie FieldInfo ab. Über FieldInfo rufen Sie Attributes ab.

Bei diesem Enumerationswert handelt es sich um eine Zahl, die das Ergebnis eines bitweisen OR der implementierten Feldattribute darstellt.

Beispiel

In diesem Beispiel werden drei Felder erstellt, und die FieldAttributes-Werte werden angezeigt. Ein FieldAttributes-Wert kann mehrere Attribute enthalten, z. B. sowohl Public als auch Literal, wie im dritten Feld gezeigt.

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

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
 */

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
 */

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

FieldAttributes-Enumeration

Syntax

Member

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen