DispatcherTimer che consuma CPU nel tempo causando il rendering non corretto del visual WPF

Question

Ho un'app WPF che utilizza DispatcherTimer per aggiornare un segno di spunta dell'orologio.

Tuttavia, dopo che la mia applicazione è stata in funzione per circa 6 ore, gli angoli delle lancette dell'orologio non cambiano più. Ho verificato che DispatcherTimer stia ancora funzionando con Debug e che i valori dell'angolo siano ancora in fase di aggiornamento, tuttavia il rendering della schermata non riflette la modifica.

Ho anche verificato utilizzando gli strumenti WPFPerf Visual Profiler che il Tempo non contrassegnato, Tick (Time Manager) e AnimatedRenderMessageHandler (Contenuto multimediale) stanno gradualmente crescendo fino a quando non consumano quasi l'80% della CPU, tuttavia la memoria è stabile.

Il hHandRT.Angle è un riferimento ad un RotateTransform

hHandRT = new RotateTransform(_hAngle); 

Questo codice funziona perfettamente per circa 5 ore di marcia in rettilineo, ma dopo che ritardi e la variazione dell'angolo non rende allo schermo. Qualche suggerimento su come risolvere questo problema o eventuali soluzioni che potresti conoscere.

.NET 3.5, Windows Vista SP1 o Windows XP SP3 (entrambi mostrano lo stesso comportamento)

EDIT: Aggiunta di Clock Tick Funzione

//In Constructor 
... 
_dt = new DispatcherTimer(); 
_dt.Interval = new TimeSpan(0, 0, 1); 
_dt.Tick += new EventHandler(Clock_Tick); 
... 

private void Clock_Tick(object sender, EventArgs e) 
     { 

      DateTime startTime = DateTime.UtcNow; 
      TimeZoneInfo tst = TimeZoneInfo.FindSystemTimeZoneById(_timeZoneId); 
      _now = TimeZoneInfo.ConvertTime(startTime, TimeZoneInfo.Utc, tst); 
      int hoursInMinutes = _now.Hour * 60 + _now.Minute; 
      int minutesInSeconds = _now.Minute * 60 + _now.Second; 
      _hAngle = (double)hoursInMinutes * 360/720; 
      _mAngle = (double)minutesInSeconds * 360/3600; 
      _sAngle = (double)_now.Second * 360/60; 
      // Use _sAngle to showcase more movement during Testing. 
      //hHandRT.Angle = _sAngle; 
      hHandRT.Angle = _hAngle; 
      mHandRT.Angle = _mAngle; 
      sHandRT.Angle = _sAngle; 

      //DSEffect 
      // Add Shadows to Hands creating a UNIFORM light 
      //hands.Effect = textDropShadow; 
     } 

Lungo le linee di troppo accadendo nel clock tick, attualmente sto provando questo aggiustamento per vedere se aiuta. Peccato ci vogliono 5 ore per il bug di manifestarsi :(

//DateTime startTime = DateTime.UtcNow; 
    //TimeZoneInfo tst = TimeZoneInfo.FindSystemTimeZoneById(_timeZoneId); 
    //_now = TimeZoneInfo.ConvertTime(startTime, TimeZoneInfo.Utc, tst); 
    _now = _now.AddSeconds(1); 

Answer 1

Hai detto che stai creando un'istanza di Classi di clock ogni volta? Si noti che i timer di .NET si radicheranno per non essere raccolti e continueranno a sparare finché non li si interrompe e manterranno gli oggetti Clock vivi perché vengono referenziati nel timer ti evento ck.

Penso che quello che sta succedendo è che con ogni orologio che crei inizi un altro timer. All'inizio fai solo 1 evento al secondo, ma poi aggiungi un altro timer e ottieni 2 al secondo, e continuano ad accumularsi in questo modo. Alla fine vedrai il tuo gestore di Tick e AnimatedRenderMessageHandler in aumento nella CPU finché non si impantaneranno e non saranno in grado di aggiornare lo schermo. Ciò spiegherebbe anche perché l'aumento della frequenza degli spari temporizzati fa apparire i sintomi prima.

La correzione deve essere semplice: basta interrompere o disporre DispatcherTimer quando hai finito con l'oggetto Orologio.

Answer 2

Stai ammesso che sia il DispatcherTimer e concentrandosi totalmente su questo. Personalmente ho difficoltà a credere che abbia qualcosa a che fare con il timer in sé ma pensa di avere a che fare con qualsiasi cosa tu stia facendo nel segno di spunta del timer. Puoi dirci di più su quello che succede ogni volta che il timer ticchetta?

Answer 3

hHandRT.Angle = _hAngle; 
mHandRT.Angle = _mAngle; 
sHandRT.Angle = _sAngle; 

Credo che si debba guardare ancora il codice sopra.

Si sta impostando la proprietà Angolo della propria trasformazione per tutte e 3 le trasformazioni anche se non si desidera che cambino ogni secondo. Il tuo minuto cambierà ogni 60 cambiamenti e la tua ora cambierà ogni 3600 secondi. Tuttavia puoi almeno ridurre l'angolo delle ore di cambio per ogni secondo.

Ciò che accade qui è che ogni volta che si richiedono le modifiche di trasformazione a WPF, WPF accoda la richiesta alla coda di invio prioritaria e ogni secondo si sta spingendo più modifiche da fare, quindi può elaborare. E questo è l'unico motivo per cui l'utilizzo della CPU continua ad aumentare anziché la memoria.

Analisi dettagliata:

Dopo aver guardato il codice, sento il tuo evento DispatcherTimer_Tick fa troppo di calcolo, ricordate filo Dispatcher è già sovraccarico di un sacco di cose da fare come gestire il routing eventi, aggiornamento visivo, ecc, se mantieni la tua CPU più impegnata a svolgere attività personalizzate nel thread di dispatcher che anche in ogni secondo evento, continuerà sicuramente ad aumentare la coda delle attività in sospeso.

Si potrebbe pensare che sia un piccolo calcolo di moltiplicazione ma per il thread di Dispatcher può essere costoso quando si tratta di caricare fusi orari, convertire il valore temporale ecc. Si dovrebbe profilare e vedere il tempo di esecuzione del tick.

È necessario utilizzare l'oggetto System.Threading.Timer, che verrà eseguito su un altro thread, dopo ogni evento di tick, una volta terminati i calcoli degli angoli finali richiesti, è possibile passarli sul thread di Dispatcher.

come,

Dispatcher.BeginInvoke((Action)delegate(){ 
    hHandRT.Angle = _hAngle; 
    mHandRT.Angle = _mAngle; 
    sHandRT.Angle = _sAngle; 
}); 

In questo modo, si sarà riducendo il carico di lavoro a partire da fili dispatcher po '.