class BoxedInt2
{
  public readonly int _value = 42;
  void PrintValue()
  {
    Console.WriteLine(_value);
  }
}

Now, it’s possible — at least in theory — that PrintValue will print “0” due to a memory-model issue.
Here’s a usage example of BoxedInt that allows it:

class Tester
{
  BoxedInt2 _box = null;
  public void Set() {
    _box = new BoxedInt2();
  }
  public void Print() {
    var b = _box;
    if (b != null) b.PrintValue();
  }
}

Because the BoxedInt instance was incorrectly published (through a non-volatile field, _box), the thread that calls Print may observe a partially constructed object!

// Thread 1
temp = new BoxedInt2()
temp._value = 42;
_box = temp;
// Thread 2
Console.WriteLine(_box._value);

// Thread 1
temp = new BoxedInt2()
_box = temp;
// Thread 2
Console.WriteLine(_box._value);
// Thread 1
temp._value = 42;

The mainstream x86 and x64 processors implement a strong memory model where memory access is effectively volatile. So, a volatile field forces the compiler to avoid some high-level optimizations like hoisting a read out of a loop, but otherwise results in the same assembly code as a non-volatile read.

A non-volatile write could just update the value in the thread’s cache, and not the value in main memory
...
However, in C# all writes are volatile (unlike say in Java), regardless of whether you write to a volatile or a non-volatile field.

 public void Set() {
    // в переменную _box записывается ссылка на созданный объект, но _box._value оказывается в другой линейке кэша и ещё не скинута в оперативку.
    _box = new BoxedInt2(); 
    // Поток 2 вызывает _box.Print()
    // в этот момент в память скидывается другая линейка кэша, в оперативке по адресу *_box._value оказывается 42
  }

        class BoxedInt2
        {
            public readonly int _value = 42;
            public void PrintValue()
            {
                PrintValue2(_value);
            }

            private void PrintValue2(int value)
            {
                if (value == 0)
                {
                    throw new Exception();
                }
                //Console.WriteLine(value);
            }
        }
        class Tester
        {
            BoxedInt2 _box = null;
            public void Set()
            {
                _box = new BoxedInt2();
            }
            public void Print()
            {
                var b = _box;
                if (b != null) b.PrintValue();
            }
        }

        private static void Main()
        {
            var tester = new Tester();

            var setThread = new Thread(() =>
            {
                while (true)
                {
                    tester.Set();
                }
            });
            setThread.Start();

            while (true)
            {
                tester.Print();
            }
        }

You may find it surprising that a volatile read refreshes the entire cache, not just the read value. Similarly, a volatile write (i.e., every C# write) flushes the entire cache, not just the written value. These semantics are sometimes referred to as “strong volatile semantics”.

The original Java memory model designed in 1995 was based on weak volatile semantics, but was changed in 2004 to strong volatile. The weak volatile model is very inconvenient. One example of the problem is that the “safe publication” pattern is not safe. Consider this example:

volatile string[] _args = null;
public void Write() {
    string[] a = new string[2];
    a[0] = "arg1";
    a[1] = "arg2";
    _args = a;
    ...
}

public void Read() {
    if (_args != null) {
        // Under weak volatile semantics, this assert could fail!
        Debug.Assert(_args[0] != null);
    }
}

Under strong volatile semantics (i.e., the .NET and C# volatile semantics), a non-null value in the _args field guarantees that the elements of _args are also not null. The safe publication pattern is very useful and commonly used in practice.

A write of a volatile field is called a volatile write. A volatile write has “release semantics”; that is, it is guaranteed to happen after any memory references prior to the write instruction in the instruction sequence.

_a = 1; // volatile write 1
_b = 2; // volatile write 2 не может выполниться до "_a = 1"

    public class Test
    {
        public volatile bool a;
        public volatile bool b;
        public volatile bool c;


        private void ThreadFuncA()
        {
            a = true;
            if (b)
            {
                c = true;
            }
        }

        private void ThreadFuncB()
        {
            b = true;
            if (a)
            {
                c = true;
            }
        }

; функция B
            b = true;
00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        eax 
00000004  mov         dword ptr [ebp-4],ecx 
00000007  cmp         dword ptr ds:[0068A1C8h],0 
0000000e  je          00000015 
00000010  call        6C86453C 
00000015  mov         eax,dword ptr [ebp-4] 
00000018  mov         byte ptr [eax+21h],1 
            if (a)
0000001c  mov         eax,dword ptr [ebp-4] 
0000001f  cmp         byte ptr [eax+20h],0 
00000023  je          0000002C 
            {
                c = true;
00000025  mov         eax,dword ptr [ebp-4] 
00000028  mov         byte ptr [eax+22h],1 
            }
        }
0000002c  nop 
0000002d  mov         esp,ebp 
0000002f  pop         ebp 
00000030  ret

; Функция А
            a = true;
00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        eax 
00000004  mov         dword ptr [ebp-4],ecx 
00000007  cmp         dword ptr ds:[0031A1C8h],0 
0000000e  je          00000015 
00000010  call        6CA644B4 
00000015  mov         eax,dword ptr [ebp-4] 
00000018  mov         byte ptr [eax+20h],1 
            if (b)
0000001c  mov         eax,dword ptr [ebp-4] 
0000001f  cmp         byte ptr [eax+21h],0 
00000023  je          0000002C 
            {
                c = true;
00000025  mov         eax,dword ptr [ebp-4] 
00000028  mov         byte ptr [eax+22h],1 
            }
        }
0000002c  nop 
0000002d  mov         esp,ebp 
0000002f  pop         ebp 
00000030  ret