Ich stelle mir vor, dass dies als wiederholend und abgeschlossen markiert sein mag, aber ich kann für mein ganzes Leben keine klare, präzise Antwort auf diese Frage finden. Alle Antworten und Ressourcen beziehen sich fast ausschließlich auf Windows Forms und verwenden vorgefertigte Dienstprogrammklassen wie BackgroundWorker. Ich würde dieses Konzept sehr gerne in seinem Kern verstehen, damit ich das grundlegende Wissen auf andere Threading-Implementierungen anwenden kann.

Ein einfaches Beispiel dafür, was ich erreichen möchte:

//timer running on a seperate thread and raising events at set intervals
//incomplete, but functional, except for the cross-thread event raising
class Timer
{
    //how often the Alarm event is raised
    float _alarmInterval;
    //stopwatch to keep time
    Stopwatch _stopwatch;
    //this Thread used to repeatedly check for events to raise
    Thread _timerThread;
    //used to pause the timer
    bool _paused;
    //used to determine Alarm event raises
    float _timeOfLastAlarm = 0;

    //this is the event I want to raise on the Main Thread
    public event EventHandler Alarm;

    //Constructor
    public Timer(float alarmInterval)
    {
        _alarmInterval = alarmInterval;
        _stopwatch = new Stopwatch();
        _timerThread = new Thread(new ThreadStart(Initiate));
    }

    //toggles the Timer
    //do I need to marshall this data back and forth as well? or is the
    //_paused boolean in a shared data pool that both threads can access?
    public void Pause()
    {
        _paused = (!_paused);            
    }

    //little Helper to start the Stopwatch and loop over the Main method
    void Initiate()
    {
        _stopwatch.Start();
        while (true) Main();    
    }

    //checks for Alarm events
    void Main()
    {
        if (_paused && _stopwatch.IsRunning) _stopwatch.Stop();
        if (!_paused && !_stopwatch.IsRunning) _stopwatch.Start();
        if (_stopwatch.Elapsed.TotalSeconds > _timeOfLastAlarm)
        {
            _timeOfLastAlarm = _stopwatch.Elapsed.Seconds;
            RaiseAlarm();
        }
    }
}

Zwei Fragen hier; In erster Linie, wie bekomme ich das Ereignis in den Haupt-Thread, um die Interessenten über das Alarm-Ereignis zu informieren.

Zweitens in Bezug auf die Pause () -Methode, die von einem Objekt aufgerufen wird, das auf dem Hauptthread ausgeführt wird. Kann ich die Stoppuhr, die im Hintergrund-Thread erstellt wurde, direkt manipulieren, indem ich _stopwatch.start () / _ stopwatch.stop () aufrufe? Wenn nicht, kann der Haupt-Thread den Booleschen Wert _paused wie oben dargestellt anpassen, sodass der Hintergrund-Thread den neuen Wert von _paused sehen und verwenden kann?

Ich schwöre, ich habe meine Nachforschungen angestellt, aber diese (grundlegenden und kritischen) Details haben sich mir noch nicht klar gemacht.

Haftungsausschluss: Mir ist bekannt, dass Klassen verfügbar sind, die genau die Funktionen bereitstellen, die ich in meiner Timer-Klasse beschreibe. (Tatsächlich glaube ich, dass die Klasse nur Threading.Timer heißt.) Meine Frage ist jedoch nicht der Versuch, die Timer-Klasse selbst zu implementieren, sondern zu verstehen, wie die Konzepte ausgeführt werden, die sie steuern.