Me imagino que esto puede ser marcado como repetitivo y cerrado, pero no puedo por mi vida encontrar una respuesta clara y concisa a esta pregunta. Todas las respuestas y los recursos tratan casi exclusivamente con Windows Forms y utilizan clases de utilidad pre-construidas como BackgroundWorker. Me gustaría mucho entender este concepto en su núcleo, por lo que puedo aplicar el conocimiento fundamental a otras implementaciones de subprocesos.

Un simple ejemplo de lo que me gustaría lograr:

//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();
        }
    }
}

Dos preguntas aquí; principalmente, ¿cómo obtengo el evento en el hilo principal para alertar a las partes interesadas del evento de Alarma?

En segundo lugar, con respecto al método Pause (), que será llamado por un objeto que se ejecuta en el hilo principal; ¿Puedo manipular directamente el cronómetro que se creó en el hilo de fondo llamando a _stopwatch.start () / _ stopwatch.stop ()? Si no es así, ¿puede el hilo principal ajustar el booleano pausado como se ilustra arriba de tal manera que el hilo de fondo pueda ver el nuevo valor de pausado y usarlo?

Lo juro, he hecho mi investigación, pero estos detalles (fundamentales y críticos) todavía no me han sido claros.

Descargo de responsabilidad: soy consciente de que hay clases disponibles que proporcionarán la funcionalidad particular exacta que describo en mi clase Timer. (De hecho, creo que la clase se llama así, Threading.Timer) Sin embargo, mi pregunta no es un intento de ayudarme a implementar la clase Timer en sí misma, sino más bien entender cómo ejecutar los conceptos que la impulsan.