Eventos Marshalling em Threads
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.