Collapse the table of content
Expand the table of content
Important This document may not represent best practices for current development, links to downloads and other resources may no longer be valid. Current recommended version can be found here. ArchiveDisclaimer

volatile (C# Reference)

The volatile keyword indicates that a field might be modified by multiple concurrently executing threads. 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 (C# Reference) 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 while the pointer itself can be volatile, the object that it points to cannot. In other words, you cannot declare a "pointer to volatile."

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

  • An enum type with an integral base type.

  • 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.

// csharp_volatile.cs
// compile with: /target:library
class Test
   public volatile int i;

   Test(int _i)
      i = _i;

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

  • 3.10 Execution order

  • 10.4.3 Volatile fields

© 2015 Microsoft