Imagino que isso possa ser marcado como repetitivo e fechado, mas não posso, para minha vida, encontrar uma resposta clara e concisa para essa pergunta. Todas as respostas e recursos lidam quase exclusivamente com o Windows Forms e utilizam classes utilitárias pré-construídas, como o BackgroundWorker. Eu gostaria muito de entender esse conceito em seu núcleo, para que eu possa aplicar o conhecimento fundamental a outras implementações de threading.

Um exemplo simples do que eu gostaria de alcançar:

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

Duas perguntas aqui; principalmente, como faço para obter o evento para o segmento principal para alertar as partes interessadas do evento de alarme.

Secundariamente, em relação ao método Pause (), que será chamado por um objeto em execução no thread principal; Posso manipular diretamente o cronômetro que foi criado no thread em segundo plano chamando _stopwatch.start () / _ stopwatch.stop (). Se não, o thread principal pode ajustar o booleano _paused como ilustrado acima, de modo que o thread em segundo plano possa então ver o novo valor de _paused e usá-lo?

Eu juro, eu fiz minha pesquisa, mas esses detalhes (fundamentais e críticos) ainda não se tornaram claros para mim.

Disclaimer: Estou ciente de que existem classes disponíveis que fornecerão a funcionalidade específica exata que estou descrevendo na minha classe Timer. (Na verdade, acredito que a classe é chamada apenas isso, Threading.Timer) No entanto, minha pergunta não é uma tentativa de me ajudar a implementar a própria classe Timer, mas sim como executar os conceitos que a orientam.