Clock Classe

Définition

Tient à jour l’état de minutage au moment de l’exécution pour Timeline.Maintains run-time timing state for a Timeline.

public ref class Clock : System::Windows::Threading::DispatcherObject
public class Clock : System.Windows.Threading.DispatcherObject
type Clock = class
    inherit DispatcherObject
Public Class Clock
Inherits DispatcherObject
Héritage
Dérivé

Remarques

Un Timeline , seul, ne fait rien d’autre que décrire un segment de temps.A Timeline, by itself, doesn't actually do anything other than describe a segment of time. C’est l’objet de la chronologie Clock qui effectue le travail réel : il gère l’état d’exécution relatif à la temporisation pour la chronologie.It's the timeline's Clock object that does the real work: it maintains timing-related run-time state for the timeline.

Dans la plupart des cas, une horloge est créée automatiquement pour votre chronologie.In most cases, a clock is created automatically for your timeline. Lorsque vous animez à l’aide de Storyboard ou de la BeginAnimation méthode, les horloges sont automatiquement créées pour vos chronologies et animations et appliquées à leurs propriétés ciblées.When you animate by using a Storyboard or the BeginAnimation method, clocks are automatically created for your timelines and animations and applied to their targeted properties. Pour obtenir des exemples, consultez Comment : animer une propriété à l’aide d’un Storyboard et Comment : animer une propriété sans utiliser de Storyboard.For examples, see How to: Animate a Property by Using a Storyboard and How to: Animate a Property Without Using a Storyboard.

Vous pouvez également créer un Clock explicitement à l’aide de la CreateClock méthode.You can also create a Clock explicitly by using the CreateClock method. Dans les scénarios gourmands en performances, tels que l’animation d’un grand nombre d’objets similaires, la gestion de votre propre Clock utilisation peut offrir des avantages en matière de performances.In performance-intensive scenarios, such as animating large numbers of similar objects, managing your own Clock use can provide performance benefits.

Les horloges sont organisées en arborescences qui correspondent à la structure de l' Timeline arborescence des objets à partir de laquelle elles sont créées.Clocks are arranged in trees that match the structure of the Timeline objects tree from which they are created. L’horloge racine d’une telle arborescence de minutage peut être manipulée de manière interactive (suspendue, reprise, arrêtée, etc.) en récupérant son Controller .The root clock of such a timing tree can be interactively manipulated (paused, resumed, stopped, and so on) by retrieving its Controller. Les horloges non racines ne peuvent pas être contrôlées directement.Non-root clocks cannot be directly controlled.

Une fois créée, une horloge ne peut pas être modifiée (mais elle peut être manipulée).Once created, a clock cannot be modified (but it can be manipulated).

Utilisation d’une chronologie comme minuteurUsing a Timeline as a Timer

L’horloge d’une chronologie progresse uniquement lorsqu’un gestionnaire d’événements y est associé ou (dans le cas d’un AnimationClock objet) qu’elle est associée à une propriété.A timeline's clock will only progress when there's an event handler associated with it or (in the case of an AnimationClock object) it is associated with a property. Pour cette raison (et d’autres), il n’est pas recommandé d’utiliser un Timeline comme minuteur.For this reason (and others), it's not recommended that you use a Timeline as a timer.

Notes pour les héritiers

Les classes dérivées doivent implémenter GetCurrentTimeCore() si elles souhaitent modifier le flux de temps pour cette horloge.Derived classes should implement GetCurrentTimeCore() if they want to modify how time flows for this clock. Les classes dérivées peuvent être créées pour effectuer un travail supplémentaire lorsque l’horloge se répète, saute, recherche, commence, suspend, reprend ou s’arrête en substituant DiscontinuousTimeMovement() les SpeedChanged() méthodes, et Stopped() .Derived classes can be made to do additional work when the clock repeats, skips, seeks, begins, pauses, resumes, or stops by overriding the DiscontinuousTimeMovement(), SpeedChanged(), and Stopped() methods.

Constructeurs

Clock(Timeline)

Initialise une nouvelle instance de la classe Clock à l'aide du Timeline spécifié en tant que modèle.Initializes a new instance of the Clock class, using the specified Timeline as a template. Le nouvel objet Clock n'a pas d'enfants.The new Clock object has no children.

Propriétés

Controller

Obtient un ClockController qui peut être utilisé pour démarrer, suspendre, reprendre, rechercher, ignorer, arrêter ou supprimer ce Clock.Gets a ClockController that can be used to start, pause, resume, seek, skip, stop, or remove this Clock.

CurrentGlobalSpeed

Obtient la fréquence à laquelle l’heure de l’horloge s’écoule actuellement par rapport à l’heure réelle.Gets the rate at which the clock's time is currently progressing, compared to real-world time.

CurrentGlobalTime

Obtient l'heure globale actuelle, établie par le système de minuterie WPFWPF.Gets the current global time, as established by the WPFWPF timing system.

CurrentIteration

Obtient l'itération actuelle de cette horloge.Get the current iteration of this clock.

CurrentProgress

Obtient la progression actuelle de ce Clock dans son itération actuelle.Gets the current progress of this Clock within its current iteration.

CurrentState

Obtient une valeur indiquant si l’horloge est actuellement Active, Filling ou Stopped.Gets a value indicating whether the clock is currently Active, Filling, or Stopped.

CurrentTime

Obtient l'heure actuelle de cette horloge dans son itération actuelle.Gets this clock's current time within its current iteration.

Dispatcher

Obtient le Dispatcher associé à DispatcherObject.Gets the Dispatcher this DispatcherObject is associated with.

(Hérité de DispatcherObject)
HasControllableRoot

Obtient une valeur qui indique si ce Clock fait partie d'une arborescence d'horloge contrôlable.Gets a value that indicates whether this Clock is part of a controllable clock tree.

IsPaused

Obtient une valeur qui indique si ce Clock ou un de ses parents est suspendu.Gets a value that indicates whether this Clock, or any of its parents, is paused.

NaturalDuration

Obtient la durée naturelle du Timeline de cette horloge.Gets the natural duration of this clock's Timeline.

Parent

Obtient l'horloge qui est le parent de cette horloge.Gets the clock that is the parent of this clock.

Timeline

Obtient le Timeline à partir duquel ce Clock a été créé.Gets the Timeline from which this Clock was created.

Méthodes

CheckAccess()

Détermine si le thread appelant a accès à ce DispatcherObject.Determines whether the calling thread has access to this DispatcherObject.

(Hérité de DispatcherObject)
DiscontinuousTimeMovement()

Est appelé, en cas d'implémentation dans une classe dérivée, à chaque répétition, ignorance ou recherche d'une horloge.When implemented in a derived class, will be invoked whenever a clock repeats, skips, or seeks.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetCanSlip()

Retourne si le Clock possède sa propre source externe pour l'heure, laquelle peut requérir une synchronisation avec le système de minuterie.Returns whether the Clock has its own external time source, which may require synchronization with the timing system.

GetCurrentTimeCore()

Obtient l'heure actuelle de cette horloge dans son itération actuelle.Gets this clock's current time within its current iteration.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
SpeedChanged()

Est appelé, en cas d'implémentation dans une classe dérivée, à chaque démarrage, ignorance, suspension, reprise d'une horloge ou lorsque le SpeedRatio de l'horloge est modifié.When implemented in a derived class, will be invoked whenever a clock begins, skips, pauses, resumes, or when the clock's SpeedRatio is modified.

Stopped()

Est appelé, en cas d'implémentation dans une classe dérivée, à chaque arrêt d'une horloge à l'aide de la méthode Stop().When implemented in a derived class, will be invoked whenever a clock is stopped using the Stop() method.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
VerifyAccess()

Garantit que le thread appelant a accès à DispatcherObject.Enforces that the calling thread has access to this DispatcherObject.

(Hérité de DispatcherObject)

Événements

Completed

Se produit lorsque cette horloge a entièrement terminé son cycle.Occurs when this clock has completely finished playing.

CurrentGlobalSpeedInvalidated

Se produit quand la vitesse de l’horloge est mise à jour.Occurs when the clock's speed is updated.

CurrentStateInvalidated

Se produit quand la propriété CurrentState de l’horloge est mise à jour.Occurs when the clock's CurrentState property is updated.

CurrentTimeInvalidated

Se produit lorsque le CurrentTime de cette horloge devient non valide.Occurs when this clock's CurrentTime becomes invalid.

RemoveRequested

Se produit lorsque la méthode Remove() est appelée sur ce Clock ou l'une de ses horloges parentes.Occurs when the Remove() method is called on this Clock or one of its parent clocks.

S’applique à