Export (0) Print
Expand All

volatile (C# Reference)

Updated: January 2010

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.

The volatile modifier is usually used for a field that is accessed by multiple threads without using the lock statement to serialize access. See How to: Create and Terminate Threads (C# Programming Guide) for an example of volatile in a multi-threaded scenario.

The volatile keyword can be applied to fields of these types:

  • Reference types.

  • Pointer types (in an unsafe context). Note that although the pointer itself can be volatile, the object that it points to cannot. In other words, you cannot declare a "pointer to volatile."

  • Types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.

  • An enum type with one of the following base types: byte, sbyte, short, ushort, int, or uint.

  • Generic type parameters known to be reference types.

  • IntPtr and UIntPtr.

The volatile keyword can only be applied to fields of a class or struct. Local variables cannot be declared volatile.

The following example shows how to declare a public field variable as volatile.

class VolatileTest
{
    public volatile int i;

    public void Test(int _i)
    {
        i = _i;
    }
}

For more information, see the following sections in the C# Language Specification:

  • 3.10 Execution order

  • 10.5.3 Volatile fields

Date

History

Reason

January 2010

Revised the list of types to which volatile can be applied.

Customer feedback.

Community Additions

ADD
Show:
© 2014 Microsoft