Perché funziona questo buffer condiviso?

Sfondo

Il seguente frammento di codice è preso da un problema in, Visual C # 2005: Come programmare, di Paul e Harvey Deitel (pagine 735). Lo snippet di codice è più o meno un'applicazione per accedere ai dati utilizzando 2 thread tramite un buffer (chiamato shared ). Basta saltare il frammento di codice, e guarda sotto se vuoi una breve descrizione di cosa sta succedendo (prima di leggere la mia domanda).

// 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

Proprio per l'idea di base di ciò che sta succedendo qui, un thread di produzione sta eseguendo che inserisce dati in un buffer (chiamato shared ). Inoltre, un thread utente sta eseguendo che ottiene i dati dal buffer.

Gli oggetti Producer e Consumer condividono in qualche modo questo buffer, che è quello che ho difficoltà a capire. Da quello che ho sempre capito sul linguaggio C #, quando un oggetto viene passato ad un metodo, è solo una copia o istanza che viene effettivamente passata. Immagino che dev'essere sbagliato, perché quando Producer mette i dati nel buffer, Consumer lo vede ...

Il frammento di codice per il buffer (nel caso qualcuno ne abbia bisogno) è il seguente (pp. 734). Onestamente non penso che avrà nulla a che fare con la risposta, e che la risposta ha più a che fare con il linguaggio C # perché in realtà tutta questa classe rappresenta un intero.

// 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

Domanda

Com'è possibile che entrambi gli oggetti (il Producer e il Consumer ) siano in grado di vedere le modifiche reciproche tra loro? (cioè quando Producer imposta i dati, Consumer può vedere i nuovi dati)

Mi manca qualcosa nella mia comprensione fondamentale di C #.