Digamos que tienes una clase simple como esta:

class MyClass
{
    private readonly int a;
    private int b;

    public MyClass(int a, int b) { this.a = a; this.b = b; }

    public int A { get { return a; } }
    public int B { get { return b; } }
}

Podría usar esta clase de manera multiproceso:

MyClass value = null;
Task.Run(() => {
    while (true) { value = new MyClass(1, 1); Thread.Sleep(10); }
});
while (true)
{
    MyClass result = value;
    if (result != null && (result.A != 1 || result.B != 1)) { 
        throw new Exception(); 
    }
    Thread.Sleep(10);
}

Mi pregunta es: ¿alguna vez veré que esto (u otro código similar de varios subprocesos) arroje una excepción? A menudo veo referencias al hecho de que las escrituras no volátiles podrían no ser vistas inmediatamente por otros hilos. Por lo tanto, parece que esto podría fallar porque la escritura en el campo de valor podría ocurrir antes de las escrituras en ay b. ¿Es esto posible o hay algo en el modelo de memoria que hace que este patrón (bastante común) sea seguro? Si es así, ¿qué es? ¿Importa solo la lectura para este propósito? ¿Importaría si a y b fueran un tipo que no se puede escribir atómicamente (por ejemplo, una estructura personalizada)?