System.Timer.Timer-Elapsed-Ereignis ausführen nach timer.Stop() wird aufgerufen,
Hintergrund: ich habe einen timer, den ich bin mit zu verfolgen, wie lange es schon da die serialPort-DataReceived-Ereignis ausgelöst wurde. Ich bin meine eigene Lösung statt mit dem eingebauten timeout-Ereignis ist, denn ich bin immer einen kontinuierlichen Strom von Daten, anstelle von senden eines Abfrage-und bekommen eine Antwort.
Das Problem:
Im DataReceived-handler-ich habe eine Anweisung zum stoppen des Timers, so dass wird nicht vergehen. das problem ist, dass viele die Zeit, führt Sie immer noch die Verstrichene handler Nachwort.
Habe ich gelesen, das ist möglich, verwenden Sie SynchronizingObject um dieses problem zu lösen, aber ich bin nicht sicher, wie Sie Sie zu erreichen, dass.
Hier ist mein code: habe ich versucht zu schneiden, alles, was ich nicht glaube, war relevant.
private System.Timers.Timer timeOut;
private System.Timers.Timer updateTimer;
public void start()
{
thread1 = new Thread(() => record());
thread1.Start();
}
public void requestStop()
{
this.stop = true;
this.WaitEventTest.Set();
}
private void record()
{
timeOut = new System.Timers.Timer(500); //** .5 Sec
updateTimer = new System.Timers.Timer(500); //** .5 Sec
timeOut.Elapsed += TimeOut_Elapsed;
updateTimer.Elapsed += updateTimer_Elapsed;
updateTimer.AutoReset = true;
comport.Open();
comport.DiscardInBuffer();
comport.Write(COMMAND_CONTINUOUSMODE + "\r");
stopwatch.Reset();
stopwatch.Start();
recordingStartTrigger(); //** Fire Recording Started Event
timeOut.Start();
updateTimer.Start();
this.waitHandleTest.WaitOne(); //** wait for test to end
timeOut.Stop();
updateTimer.Stop();
comport.Write(COMMAND_COMMANDMODE + Environment.NewLine);
comport.DiscardInBuffer();
comport.Close();
recordingStopTrigger(status); //** Fire Recording Stopped Event
stopwatch.Stop();
}
//***********************************************************************************
//** Events Handlers
private void comDataReceived_Handler(object sender, SerialDataReceivedEventArgs e)
{
double force = -100000;
string temp = "-100000";
//timeOut.SynchronizingObject.Invoke(new Action(()=> {timeOut.Stop();}), new object[] {sender, e});
timeOut.Stop();
//** I removed my action code here, keep things simple.
timeOut.Start();
}
private void TimeOut_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
timeOut.Stop();
updateTimer.Stop();
//** fire delegate that GUI will be listening to, to update graph.
if (eventComTimeOut != null && this.stop == false)
{
if (eventComTimeOut(this, new eventArgsComTimeOut(comport.PortName, "READ")))
{
//retry = true;
comport.Write(COMMAND_CONTINUOUSMODE + "\r");
updateTimer.Start();
timeOut.Start();
}
else
{
this.stop = true;
//retry = false;
this.WaitEventTest.Set();
status = eventArgsStopped.Status.failed;
}
}
}
void updateTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
//** fire delegate that GUI will be listening to, to update graph.
List<Reading> temp = new List<Reading>(report.Readings_Force);
eventNewData(this, new eventArgsNewData(temp));
}
Du musst angemeldet sein, um einen Kommentar abzugeben.
Dies ist bekanntlich Verhalten.
System.Timers.Timer
intern verwendetThreadPool
für die Ausführung. Laufzeit queue dieTimer
im threadpool. Es hätte schon in der Warteschlange, bevor Sie aufgerufen habenStop
Methode. Es wird Feuer auf die verstrichene Zeit.Um dies zu vermeiden, legen Sie
Timer.AutoReset
auf false, und starten Sie die timer-zurück in die vergangen-handler, wenn Sie einen brauchen. EinstellungAutoReset
falsch macht-timer, um das Feuer erst einmal so in Ordnung zu bekommen timer gefeuert Intervall manuell starten, den timer wieder.try
- block fügen Sie Ihre Logik, auch im Fall von Ausnahmenfinally
- block wird sichergestellt, dass yourTimer wieder starten wird.AutoReset
Habe ich einen pause-timer mit diesem code. für mich funktioniert.
Hatte das gleiche problem und nach einigen versuchen landete mit timer-Objekt zu null und ersetzen Sie die timer-variable mit einem neuen timer-Objekt, das Problem behoben wurde. Ich weiß, das ist schwer von Ressourcen. Aber es löst das problem.