Condividi tramite

Panoramica degli eventi di temporizzazione

  • Articolo

In questo argomento viene descritto come usare i cinque eventi temporali disponibili negli oggetti Timeline e Clock.

Prerequisiti

Per comprendere questo argomento, è necessario comprendere come creare e usare le animazioni. Per iniziare a usare l'animazione, consulta la panoramica sull'animazione .

Esistono diversi modi per animare le proprietà in WPF:

Poiché è possibile usarli nel markup e nel codice, gli esempi in questa panoramica usano Storyboard oggetti. Tuttavia, i concetti descritti possono essere applicati agli altri metodi di animazione delle proprietà.

Che cos'è un orologio?

Una sequenza temporale, da sola, non fa effettivamente altro se non limitarsi a descrivere un segmento di tempo. Si tratta dell'oggetto Clock della sequenza temporale che esegue il lavoro reale: mantiene lo stato di runtime correlato alla tempistica per la sequenza temporale. Nella maggior parte dei casi, ad esempio quando si usano gli storyboard, viene creato automaticamente un orologio per la sequenza temporale. È anche possibile creare un Clock in modo esplicito usando il metodo CreateClock. Per altre informazioni sugli oggetti Clock, vedere cenni preliminari sull'animazione e sul sistema di temporizzazione.

Perché usare gli eventi?

Con l'eccezione di una (ricerca allineata all'ultimo tick), tutte le operazioni di temporizzazione interattive sono asincrone. Non c'è modo per voi di sapere esattamente quando verranno eseguiti. Questo può essere un problema quando si dispone di altro codice che dipende dall'operazione di temporizzazione. Si supponga di voler arrestare una sequenza temporale che ha animato un rettangolo. Dopo l'arresto della sequenza temporale, si modifica il colore del rettangolo.

myStoryboard.Stop(myRectangle);

// This statement might execute
// before the storyboard has stopped.
myRectangle.Fill = Brushes.Blue;

myStoryboard.Stop(myRectangle)

' This statement might execute
' before the storyboard has stopped.
myRectangle.Fill = Brushes.Blue

Nell'esempio precedente, la seconda riga di codice potrebbe essere eseguita prima che lo storyboard si fermi. Questo perché fermarsi è un'operazione asincrona. Indicare a una sequenza temporale o all'orologio di arrestarsi crea una "richiesta di arresto" in un certo senso, che non viene elaborata fino al tick successivo del motore temporale.

Per eseguire comandi al termine di una linea temporale, usare gli eventi di temporizzazione. Nell'esempio seguente viene usato un gestore eventi per modificare il colore di un rettangolo dopo che lo storyboard smette di giocare.

// Register for the CurrentStateInvalidated timing event.
myStoryboard.CurrentStateInvalidated += new EventHandler(myStoryboard_CurrentStateInvalidated);

' Register for the CurrentStateInvalidated timing event.
AddHandler myStoryboard.CurrentStateInvalidated, AddressOf myStoryboard_CurrentStateInvalidated

// Change the rectangle's color after the storyboard stops.
void myStoryboard_CurrentStateInvalidated(object sender, EventArgs e)
{
    Clock myStoryboardClock = (Clock)sender;
    if (myStoryboardClock.CurrentState == ClockState.Stopped)
    {
        myRectangle.Fill = Brushes.Blue;
    }
}

' Change the rectangle's color after the storyboard stops. 
Private Sub myStoryboard_CurrentStateInvalidated(ByVal sender As Object, ByVal e As EventArgs)
    Dim myStoryboardClock As Clock = CType(sender, Clock)
    If myStoryboardClock.CurrentState = ClockState.Stopped Then
        myRectangle.Fill = Brushes.Blue
    End If
End Sub

Per un esempio più completo, vedere Ricevere una notifica quando lo stato di un orologio cambia.

Eventi pubblici

Le classi Timeline e Clock forniscono entrambe cinque eventi temporali. Nella tabella seguente sono elencati questi eventi e le condizioni che li attivano.

Evento Attivazione di un'operazione interattiva Altri trigger
Completato Salta al riempimento L'orologio si completa.
VelocitàGlobaleCorrenteInvalidata Pausa, riprendi, cerca, imposta rapporto di velocità, salta per riempire, ferma L'orologio inverte, accelera, avvia o arresta.
StatoCorrenteInvalidato Iniziare, saltare il riempimento, arrestare L'orologio inizia, si arresta o riempie.
OraCorrenteInvalidata Inizia, cerca, skip to fill, ferma L'orologio avanza.
RichiestaRimossa Togliere

Ticking e consolidamento degli eventi

Quando si animano gli oggetti in WPF, si tratta del motore di temporizzazione che gestisce le animazioni. Il motore di temporizzazione tiene traccia della progressione del tempo e calcola lo stato di ogni animazione. Esegue molti passaggi di valutazione di questo tipo in un secondo. Questi passaggi di valutazione sono noti come "segnali di spunta".

Anche se i ticchettii si verificano frequentemente, è possibile che accadano molte cose tra un ticchettio e l'altro. Ad esempio, una sequenza temporale potrebbe essere arrestata, avviata e arrestata di nuovo, nel qual caso il relativo stato corrente verrà modificato tre volte. In teoria, l'evento potrebbe essere generato più volte in un singolo tick; tuttavia, il motore temporale consolida gli eventi, in modo che ogni evento possa essere attivato al massimo una volta per intervallo.

Registrazione per gli eventi

Esistono due modi per registrarsi per gli eventi di tempistica: puoi registrarti con la sequenza temporale o con l'orologio creato dalla sequenza temporale. La registrazione per un evento direttamente con un orologio è piuttosto semplice, anche se può essere eseguita solo dal codice. È possibile registrarsi per eventi che includono una sequenza temporale tramite markup o codice. La sezione successiva descrive come eseguire la registrazione per gli eventi di clock con una sequenza temporale.

Registrazione per gli eventi orari con una cronologia

Anche se gli eventi di una sequenza temporale, come Completed, CurrentGlobalSpeedInvalidated, CurrentStateInvalidated, CurrentTimeInvalidatede RemoveRequested, sembrano essere collegati alla sequenza temporale, la registrazione per questi eventi collega effettivamente un gestore degli eventi con il Clock creato per la sequenza temporale.

Quando si esegue la registrazione per l'evento Completed in una sequenza temporale, ad esempio, si indica al sistema di registrarsi per l'evento Completed di ogni orologio creato per la sequenza temporale. Nel codice è necessario registrarsi per questo evento prima che venga creato il Clock per questa sequenza temporale; in caso contrario, non si riceverà alcuna notifica. Questo avviene automaticamente in XAML; il parser si registra automaticamente per l'evento prima che venga creato il Clock.

Vedere anche