Múltiples textos dicen que al implementar el bloqueo doble control en .NET, el campo que está bloqueando debe tener aplicado un modificador volátil. Pero ¿por qué exactamente? Teniendo en cuenta el siguiente ejemplo:

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

¿Por qué "lock (syncRoot)" no logra la consistencia de memoria necesaria? ¿No es cierto que después de la frase de "bloqueo" tanto la lectura como la escritura serían volátiles y, por lo tanto, se lograría la consistencia necesaria?