Ouvi muitas vezes que, no modelo de memória .NET 2.0, as gravações sempre usam cercas de liberação. Isso é verdade? Isso significa que, mesmo sem barreiras ou bloqueios explícitos de memória, é impossível observar um objeto parcialmente construído (considerando apenas os tipos de referência) em um thread diferente daquele em que foi criado? Obviamente, estou excluindo casos em que o construtor vaza othis referência.

Por exemplo, digamos que tivemos o tipo de referência imutável:

public class Person
{
    public string Name { get; private set; }
    public int Age { get; private set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Seria possível, com o código a seguir, observar qualquer saída diferente de "John 20" e "Jack 21", dizer "null 20" ou "Jack 0"?

// We could make this volatile to freshen the read, but I don't want
// to complicate the core of the question.
private Person person;

private void Thread1()
{
    while (true)
    {
        var personCopy = person;

        if (personCopy != null)
            Console.WriteLine(personCopy.Name + " " + personCopy.Age);
    }
}

private void Thread2()
{
    var random = new Random();

    while (true)
    {
        person = random.Next(2) == 0
            ? new Person("John", 20)
            : new Person("Jack", 21);
    }
}

Isso também significa que posso criar todos os campos compartilhados de tipos de referência profundamente imutáveisvolatile e (na maioria dos casos) apenas continuar meu trabalho?