Ich habe den folgenden Code (aus Gründen der Lesbarkeit eingeschränkt):

Hauptklasse:

<code>public StartProcess()
{
    Thinker th = new Thinker();
    th.DoneThinking += new Thinker.ProcessingFinished(ThinkerFinished);
    th.StartThinking();
}

void ThinkerFinished()
{
    Console.WriteLine("Thinker finished");
}
</code>

Denkerklasse:

<code>public class Thinker
{
    private System.Timers.Timer t;

    public delegate void ProcessingFinished();
    public event ProcessingFinished DoneThinking;

    BackgroundWorker backgroundThread;

    public Thinker() { }

    public StartThinking()
    {
        t = new System.Timers.Timer(5000);    // 5 second timer
        t.AutoReset = false;
        t.Elapsed += new System.Timers.ElapsedEventHandler(t_Elapsed);
        t.Start();

        // start a background thread to do the thinking
        backgroundThread = new BackgroundWorker();
        backgroundThread.DoWork += new DoWorkEventHandler(BgThread_DoWork);
        backgroundThread.RunWorkerAsync();
    }

    void t_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        DoneThinking();
    }

    BgThread_DoWork(object sender, DoWorkEventArgs e)
    {
        // work in here should go for much less than 5 seconds
        // it will die if it doesn't

        t.Stop();
        DoneThinking();
    }
}
</code>

Was ich ursprünglich erwartet hatte, war, dass die Ereignisbehandlungsroutine in der Hauptklasse verhindern würde, dass der Denker Müll sammelt.

Anscheinend ist das nicht der Fall.

Ich frage mich jetzt, ob Garbage Collection stattfinden wird, unabhängig davon, ob dieser Thread "beschäftigt" ist oder nicht. Mit anderen Worten, besteht die Möglichkeit, dass Müll gesammelt wird, bevor die 5-Sekunden-Zeitüberschreitung abgelaufen ist?

Kann der Garbage Collector meinen Thinker abholen, bevor die Verarbeitung abgeschlossen ist?