Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

Création de déclencheurs et d’actions personnalisés (Kit de développement logiciel Blend pour Silverlight)

Relations de cause à effet du modèle Triggers et Actions. Un Trigger réagit à une cause et appelle une ou plusieurs Actions.

Un Trigger est un objet qui réagit à une condition spécifique (telle que le déclenchement d’un événement ou la définition d’une propriété sur une certaine valeur) en appelant une ou plusieurs Actions associées. Les Triggers peuvent prendre la forme d’un EventTrigger, par exemple, qui déclenche une Action lorsqu’un événement de souris ou de clavier survient, ou d’un CollisionTrigger, qui déclenche une Action lorsque deux objets entrent en collision. Les Triggers peuvent être étendus, ce qui vous permet de créer des déclencheurs personnalisés répondant à des besoins très variés. Pour pouvoir être reconnu par les Behaviors à l’exécution, un Trigger doit respecter une syntaxe de base.

L’exemple de code suivant illustre un Trigger de ligne de base :

public class Trigger1 : TriggerBase<DependencyObject>
{
    protected override void OnAttached()
    {
        base.OnAttached();

        // Insert code that you want to run when the Trigger is attached to an object.
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();

        // Insert code that you want to run when the Trigger is removed from an object.
    }

    //
    // To invoke any associated Actions when this Trigger gets called, use
    // this.InvokeActions(o), where o is an object that you can pass in as a parameter.
    //
}

Dans l'exemple de code précédent, la classe est étendue à partir de TriggerBase, un type fourni dans le System.Windows.Interactivity.dll. Une fois la classe étendue à partir de TriggerBase, substituez les méthodes OnAttached et OnDetaching comme indiqué dans l'exemple de code.

La méthode OnDetaching est appelée immédiatement avant que le Trigger ne soit dissocié de son AssociatedObject. Cela signifie que l’objet continuera à être disponible dans l’étendue du Trigger, ce qui permet de poursuivre l’exécution du code jusqu’à la sortie de la méthode OnDetaching (pour décrocher les gestionnaires d’événements qui s’y trouvent, par exemple).

Ce qui compte le plus avec un Trigger, c’est qu’il se déclenche. Pour que votre Trigger se déclenche, vous devez créer un appel à la méthode InvokeActions. Lorsque la méthode InvokeActions est appelée, toutes les Actions associées à ce Trigger sont invitées à agir.

Un Trigger est un objet qui peut uniquement attendre que quelque chose se produise. Une Action est un objet qui peut uniquement faire quelque chose.

L’exemple de code suivant illustre une Action de ligne de base :

public class MyAction : TriggerAction<DependencyObject>
{
    public MyAction()
    {
        // Insert code required for object creation below this point.
    }

    protected override void Invoke(object o)
    {
        // Insert code that defines what the Action will do when it is triggered or invoked.
    }
}

Le Trigger appelle la méthode Invoke ; vous devez donc veiller à ce que le code à exécuter par l’Action soit accessible sous une forme ou une autre au sein de la méthode Invoke. L’exemple de code suivant illustre une Action qui, lorsqu’elle est appelée, affiche un objet MessageBox :

public class ShowMessageBoxAction : TriggerAction<DependencyObject>
{
    public string Message
    {
        get { return (string)GetValue(MessageProperty); }
        set { SetValue(MessageProperty, value); }
    }

    public static readonly DependencyProperty MessageProperty = DependencyProperty.Register("Message", typeof(string), typeof(ShowMessageBoxAction), new PropertyMetadata(""));

    public ShowMessageBoxAction()
    {
        // Insert code required for object creation below this point.
    }

    protected override void Invoke(object o)
    {
        MessageBox.Show(Message);
    }
}

Dans l’exemple de code qui précède, l’Action est plus complexe que l’Action simple illustrée précédemment, mais les caractéristiques qui définissent une Action existent toujours. ShowMessageBoxAction part de TriggerAction et se substitue à la méthode Invoke.

Par défaut, l’Action a accès uniquement à la propriété AssociatedObject, qui est l’élément auquel elle est attachée, bien que vous puissiez changer l’élément ciblé par votre Action. Pour faire en sorte que votre Action cible un autre élément, étendez la classe représentant l’Action à partir de la classe TargetedTriggerAction et non à partir de la classe TriggerAction :

public class MyAction : TargetedTriggerAction<DependencyObject>
{
    // See TriggerAction in the preceding code sample...
}

Après avoir étendu la classe à partir de TargetedTriggerAction, vous pouvez accéder à l’élément ciblé à l’aide des propriétés TargetName et Target. Votre AssociatedObject pointera toujours vers l’élément auquel votre Action est actuellement associée ; évitez donc d’utiliser AssociatedObject et les propriétés TargetName ou Target de façon interchangeable.

Afficher: