Por que esse buffer compartilhado funciona?

Plano de fundo

O seguinte trecho de código foi retirado de um problema em Visual C # 2005: Como programar, por Paul e Harvey Deitel (pp. 735). O snippet de código é mais ou menos um aplicativo para acessar dados usando 2 threads por meio de um buffer (chamado shared ). Apenas pule o trecho de código e veja abaixo se você gostaria de uma breve descrição do que está acontecendo (antes de ler a minha pergunta).

// Fig. 15.8: UnsynchronizedBufferTest.cs
// Showing multiple threads modifying a shared object without
// synchronization.
using System;
using System.Threading;

class UnsynchronizedBufferTest
{
    static void Main(string[] args)
    {
        // create shared object used by threads
        UnsynchronizedBufferTest shared = new UnsynchronizedBuffer();

        // Random object used by each thread
        Random random = new Random();

        // create Producer and Consumer objects 
        Producer producer = new Producer(shared, random);
        Consumer consumer = new Consumer(shared, random);

        // create threads for producer and consumer and set
        // delegates for each thread
        Thread producerThread =
            new Thread(new ThreadStart(producer.Produce));
        producerThread.Name = "Producer";

        Thread consumerThread =
            new Thread(new ThreadStart(consumer.Consume));
        consumerThread.Name = "Consumer";

        // start each thread
        producerThread.Start();
        consumerThread.Start();
    } // end Main
} // end class UnsynchronizedBufferTest

Apenas pela ideia básica do que está acontecendo aqui, um thread produtor está executando os dados puts em um buffer (chamado shared ). Além disso, um segmento de consumidor está executando que obtém os dados do buffer.

Os objetos Producer e Consumer estão de alguma forma compartilhando esse buffer, que é o que estou tendo dificuldade em entender. Pelo que eu sempre entendi sobre a linguagem C #, quando um objeto é passado para um método, é apenas uma cópia ou instância que realmente é passada. Eu acho que deve estar errado, porque quando o Producer coloca os dados no buffer, o Consumer vê isso ...

O trecho de código para o buffer (caso alguém precise disso) é o seguinte (pp. 734). Honestamente, eu não acho que terá nada a ver com a resposta, e que a resposta tem mais a ver com a linguagem C #, porque realmente toda essa classe representa é um inteiro.

// Fig. 15.7: UnsynchronizedBuffer.cs
// An unsynchronized shared buffer implementation.
using System;
using System.Threading;

// this class represents a single shared int
public class UnsynchronizedBuffer : Buffer
{
    // buffer shared by producer and consumer threads
    private int buffer = -1;

    // property buffer
    public int Buffer
    {
        get
        {
            Console.WriteLine("{0} reads {1}",
                Thread.CurrentThread.Name, buffer);
            return buffer;
        } // end get
        set
        {
            Console.WriteLine("{0} writes {1}",
                Thread.CurrentThread.Name, value);
            buffer = value;
        } // end set
    } // end property Buffer
} // end class UnsynchronizedBuffer

Pergunta

Como é possível que os dois objetos (o Producer e o Consumer ) consigam ver as alterações que cada um faz? (ou seja, quando o Producer definir os dados, o Consumer poderá ver os novos dados)

Eu devo estar faltando alguma coisa no meu entendimento fundamental do C #.