FieldAttributes Enumeration


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Specifies flags that describe the attributes of a field.

This enumeration has a FlagsAttribute attribute that allows a bitwise combination of its member values.

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

public enum class FieldAttributes

Member nameDescription

Specifies that the field is accessible throughout the assembly.


Specifies that the field is accessible only by subtypes in this assembly.


Specifies that the field is accessible only by type and subtypes.


Specifies that the field is accessible by subtypes anywhere, as well as throughout this assembly.


Specifies the access level of a given field.


Specifies that the field has a default value.


Specifies that the field has marshaling information.


Specifies that the field has a relative virtual address (RVA). 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.


Specifies that the field is initialized only, and can be set only in the body of a constructor.


Specifies that the field's value is a compile-time (static or early bound) constant. Any attempt to set it throws a FieldAccessException.


Specifies that the field does not have to be serialized when the type is remoted.


Reserved for future use.


Specifies that the field is accessible only by the parent type.


Specifies that the field cannot be referenced.


Specifies that the field is accessible by any member for whom this scope is visible.




Specifies that the common language runtime (metadata internal APIs) should check the name encoding.


Specifies a special method, with the name describing how the method is special.


Specifies that the field represents the defined type, or else it is per-instance.

FieldAttributes uses the value from FieldAccessMask to mask off only the parts of the attribute value that pertain to the accessibility. For example, the following code determines if Attributes has the public bit set.

FieldInfo^ fi = obj->GetType()->GetField("field1");

if ((fi->Attributes & FieldAttributes::FieldAccessMask) ==
    Console::WriteLine("{0:s} is public. Value: {1:d}", fi->Name, fi->GetValue(obj));

To get the FieldAttributes, first get the class Type. From the Type, get the FieldInfo. From the FieldInfo, get the Attributes.

The enumerated value is a number representing the bitwise OR of the attributes implemented on the field.

In this example, three fields are built and the FieldAttributes values are displayed. 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
    // Make three fields:
    // The first field is private.
    String^ m_field;

    // The second field is 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:

m_field = "String A"; attributes: Private
Field = "String B"; attributes: Public
FieldC = "String C"; attributes: Public, Static, Literal, HasDefault

Universal Windows Platform
Available since 8
.NET Framework
Available since 1.1
Portable Class Library
Supported in: portable .NET platforms
Available since 2.0
Windows Phone Silverlight
Available since 7.0
Windows Phone
Available since 8.1
Return to top