C # orden de ejecución de la sentencia

Mi pregunta es sobre las garantías de orden de ejecución en C # (y, presumiblemente, .Net en general). Doy ejemplos de Java con los que sé algo que comparar.

Para Java (de “Java Concurrency in Practice”)

No hay garantía de que las operaciones en un subproceso se realicen en el orden dado por el progtwig, siempre que la reordenación no sea detectable desde ese subproceso, incluso si la reordenación es evidente para otros subprocesos.

Entonces el código

y = 10; x = 5; a = b + 10; 

en realidad puede asignar a = b + 10 antes de asignar y = 10

Y en Java (del mismo libro).

Todo lo que hace el hilo A en o antes de un bloque sincronizado es visible para el hilo B cuando inicia un bloque sincronizado protegido por el mismo locking.

asi que en Java

  y = 10; synchronized(lockObject) { x = 5; } a = b + 10; 

Se garantiza que y = 10 y x = 5 se ejecutan antes de a = b + 10 (no sé si se garantiza que y = 10 se ejecute antes de x = 5).

¿Qué garantías ofrece el código C # para el orden de ejecución de las declaraciones C #?

  y = 10; lock(lockObject) { x = 5; } a = b + 10; 

Estoy particularmente interesado en una respuesta que pueda proporcionar una referencia definitiva o alguna otra justificación realmente significativa, ya que las garantías de este tipo son difíciles de probar porque se refieren a lo que el comstackdor puede hacer, no a lo que hace cada vez y porque falla. Va a ser muy difícil reproducir errores intermitentes cuando los hilos tocan cosas en el orden equivocado.