La parola chiave volatile indica che un campo potrebbe essere modificato da più thread eseguiti contemporaneamente. I campi dichiarati volatile non sono soggetti a ottimizzazioni del compilatore che presuppongono l'accesso da un singolo thread. In questo modo nel campo è sempre presente il valore più aggiornato.

Il modificatore volatile è in genere utilizzato per un campo al quale accedono più thread senza utilizzare l'istruzione Istruzione lock per la serializzazione dell'accesso. Per un esempio di volatile in uno scenario multithreading.

La parola chiave volatile può essere applicata ai seguenti tipi di campi:

• Tipi di riferimento.

• Tipi puntatore in un contesto unsafe. Si noti che mentre il puntatore stesso può essere volatile, l'oggetto al quale punta non può esserlo. In altre parole, non è possibile dichiarare un "puntatore volatile".

• Tipi integrali quali sbyte, byte, short, ushort, int, uint, char, float e bool.

• Tipo enum con un tipo base integrale.

• Parametri di tipo generico riconosciuti come tipi di riferimento.

• IntPtr e UIntPtr.

La parola chiave volatile può essere applicata solo a campi di una classe o una struttura. Le variabili locali non possono essere dichiarate volatile.

Piu avanti impareremo l'uso dei Thread e come gestirli appunto con la classe volatile.
Ma guardiamo un semplice esempio di come viene scritta una classe volatile.

class Test
{
   public volatile int i;

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

Oppure

using System;

public class Singleton
{
    static object sync = new object();
    
    static volatile Singleton singleton = null;
    
    private Singleton()
    {
    }
    
    public static Singleton GetSingleton()    
    {
        if (singleton == null)
        {
            lock(sync)
            {
                if (singleton == null)
                singleton = new Singleton();
		volatile Box volume = 123.45; 
            }
        }
        
        return(singleton);
    }
}