FieldAttributes Výčet

Definice

Určuje příznaky, které popisují atributy pole.Specifies flags that describe the attributes of a field.

Tento výčet má atribut FlagsAttribute, který umožňuje bitové kombinace hodnot členů.

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
Dědičnost
FieldAttributes
Atributy

Pole

Assembly 3

Určuje, že pole je přístupné v rámci sestavení.Specifies that the field is accessible throughout the assembly.

FamANDAssem 2

Určuje, že pole je přístupné pouze podtypy v tomto sestavení.Specifies that the field is accessible only by subtypes in this assembly.

Family 4

Určuje, že pole je přístupné pouze pomocí typu a podtypů.Specifies that the field is accessible only by type and subtypes.

FamORAssem 5

Určuje, že pole je přístupné pro podtypy kdekoli a také v celém tomto sestavení.Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.

FieldAccessMask 7

Určuje úroveň přístupu daného pole.Specifies the access level of a given field.

HasDefault 32768

Určuje, že pole má výchozí hodnotu.Specifies that the field has a default value.

HasFieldMarshal 4096

Určuje, že pole obsahuje zařazovací informace.Specifies that the field has marshaling information.

HasFieldRVA 256

Určuje, že pole má relativní virtuální adresu (RVA).Specifies that the field has a relative virtual address (RVA). Adresa RVA je umístění těla metody v aktuálním obrázku jako adresa relativní vzhledem k začátku souboru obrázku, ve kterém se nachází.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

Určuje, že pole je inicializováno pouze a lze jej nastavit pouze v těle konstruktoru.Specifies that the field is initialized only, and can be set only in the body of a constructor.

Literal 64

Určuje, že hodnota pole je konstanta doby kompilace (statická nebo časná mez).Specifies that the field's value is a compile-time (static or early bound) constant. Libovolný pokus o nastavení vyvolá FieldAccessException .Any attempt to set it throws a FieldAccessException.

NotSerialized 128

Určuje, že pole nemusí být serializováno, pokud je typ vzdálený.Specifies that the field does not have to be serialized when the type is remoted.

PinvokeImpl 8192

Vyhrazeno pro budoucí použití.Reserved for future use.

Private 1

Určuje, že pole je přístupné pouze nadřazeným typem.Specifies that the field is accessible only by the parent type.

PrivateScope 0

Určuje, že na pole se nedá odkazovat.Specifies that the field cannot be referenced.

Public 6

Určuje, že pole je dostupné jakýmkoli členem, pro který je tento obor viditelný.Specifies that the field is accessible by any member for whom this scope is visible.

ReservedMask 38144

Vyhrazeno.Reserved.

RTSpecialName 1024

Určuje, že modul CLR (Common Language Runtime) (interní rozhraní API pro metadata) by měl kontrolovat kódování názvu.Specifies that the common language runtime (metadata internal APIs) should check the name encoding.

SpecialName 512

Určuje speciální metodu s názvem, který popisuje způsob, jakým je metoda speciální.Specifies a special method, with the name describing how the method is special.

Static 16

Určuje, že pole představuje definovaný typ, nebo jinak je na instanci.Specifies that the field represents the defined type, or else it is per-instance.

Příklady

V tomto příkladu jsou sestavena tři pole a FieldAttributes hodnoty jsou zobrazeny.In this example, three fields are built and the FieldAttributes values are displayed. FieldAttributesHodnota může obsahovat více než jeden atribut, například obojí Public a Literal , jak je uvedeno v třetím poli.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

Poznámky

FieldAttributes používá hodnotu z FieldAccessMask k maskování jenom těch částí hodnoty atributu, které se týkají přístupnosti.FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. Například následující kód určuje, zda Attributes má nastaven veřejný bit.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

Chcete-li získat FieldAttributes , nejprve získejte třídu Type .To get the FieldAttributes, first get the class Type. Z rozhraní Type Získejte FieldInfo .From the Type, get the FieldInfo. Z rozhraní FieldInfo Získejte Attributes .From the FieldInfo, get the Attributes.

Výčtová hodnota je číslo představující bitové nebo atributy implementované v poli.The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

Platí pro