Обеспечение порядка выполнения операторов в C #

У меня вопрос о гарантиях порядка выполнения в C # (и, предположительно, в .Net в целом). Я привожу примеры Java, с которыми я знаю кое-что для сравнения.

Для Java (из "Java Concurrency in Practice")

Нет гарантии, что операции в одном потоке будут выполняться в порядке, заданном программой, поскольку до тех пор, пока переупорядочение не обнаруживается изнутри этого потока, даже если переупорядочение очевидно для других потоков.

Таким образом, код

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

может фактически присвоить a = b + 10 Перед назначением y = 10

И в Java (из той же книги)

Все, что поток A делает в синхронизированном блоке или до него, видно потоку B, когда он запускает синхронизированный блок, защищенный той же блокировкой.

поэтому в Java

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

y = 10 и x = 5 гарантированно запускаются до a = b + 10 (я не знаю, гарантированно ли y = 10 будет выполняться до x = 5).

Какие гарантии дает код C # для порядка выполнения операторов C #

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

Меня особенно интересует ответ, который может предоставить исчерпывающую ссылку или другое действительно значимое обоснование, поскольку такие гарантии трудно проверить, потому что они касаются того, что компилятору разрешено делать, а не то, что он делает каждый раз, и потому что, когда они выходят из строя, вам будет очень трудно воспроизводить периодические ошибки, когда потоки сталкиваются с вещами только в неправильном порядке.