Partager via

Créer des Xamarin.Forms comportements

  • Article

Xamarin.Forms les comportements sont créés en dérivant de la classe Behavior ou Behavior<T> . Cet article montre comment créer et consommer Xamarin.Forms des comportements.

Vue d’ensemble

Le processus de création d’un Xamarin.Forms comportement est le suivant :

  1. Créez une classe qui hérite de la classe Behavior ou Behavior<T>, où T est le type du contrôle auquel le comportement doit s’appliquer.
  2. Remplacez la méthode OnAttachedTo pour effectuer toute configuration nécessaire.
  3. Remplacez la méthode OnDetachingFrom pour effectuer tout nettoyage nécessaire.
  4. Implémentez la fonctionnalité clé du comportement.

La structure qui en résulte est illustrée dans l’exemple de code suivant :

public class CustomBehavior : Behavior<View>
{
    protected override void OnAttachedTo (View bindable)
    {
        base.OnAttachedTo (bindable);
        // Perform setup
    }

    protected override void OnDetachingFrom (View bindable)
    {
        base.OnDetachingFrom (bindable);
        // Perform clean up
    }

    // Behavior implementation
}

La méthode OnAttachedTo est déclenchée immédiatement après l’attachement du comportement à un contrôle. Cette méthode reçoit une référence au contrôle auquel elle est attachée et peut être utilisée pour inscrire des gestionnaires d’événements ou effectuer une autre configuration nécessaire à la prise en charge de la fonctionnalité du comportement. Par exemple, vous pouvez vous abonner à un événement sur un contrôle. La fonctionnalité du comportement serait alors implémentée dans le gestionnaire d’événements pour l’événement en question.

La méthode OnDetachingFrom est déclenchée quand le comportement est supprimé du contrôle. Cette méthode reçoit une référence au contrôle auquel elle est attachée et est utilisée pour effectuer tout nettoyage nécessaire. Par exemple, vous pouvez vous désabonner d’un événement sur un contrôle pour empêcher les fuites de mémoire.

Le comportement peut ensuite être consommé en l’attachant à la collection Behaviors du contrôle approprié.

Création d’un Xamarin.Forms comportement

L’exemple d’application montre un NumericValidationBehavior, qui met en évidence la valeur entrée par l’utilisateur dans un contrôle Entry en rouge, si elle n’est pas un double. Le comportement est illustré dans l’exemple de code suivant :

public class NumericValidationBehavior : Behavior<Entry>
{
    protected override void OnAttachedTo(Entry entry)
    {
        entry.TextChanged += OnEntryTextChanged;
        base.OnAttachedTo(entry);
    }

    protected override void OnDetachingFrom(Entry entry)
    {
        entry.TextChanged -= OnEntryTextChanged;
        base.OnDetachingFrom(entry);
    }

    void OnEntryTextChanged(object sender, TextChangedEventArgs args)
    {
        double result;
        bool isValid = double.TryParse (args.NewTextValue, out result);
        ((Entry)sender).TextColor = isValid ? Color.Default : Color.Red;
    }
}

NumericValidationBehavior dérive de la classe Behavior<T>, où T est une Entry. La méthode OnAttachedTo inscrit un gestionnaire d’événements pour l’événement TextChanged, tandis que la méthode OnDetachingFrom le désinscrit de l’événement TextChanged pour empêcher les fuites de mémoire. La fonctionnalité clé du comportement est fournie par la méthode OnEntryTextChanged, qui analyse la valeur entrée par l’utilisateur dans l’Entry et définit la propriété TextColor sur rouge si la valeur n’est pas un double.

Remarque

Xamarin.Forms ne définit pas le BindingContext comportement, car les comportements peuvent être partagés et appliqués à plusieurs contrôles par le biais de styles.

Consommation d’un Xamarin.Forms comportement

Chaque Xamarin.Forms contrôle a une Behaviors collection, à laquelle un ou plusieurs comportements peuvent être ajoutés, comme illustré dans l’exemple de code XAML suivant :

<Entry Placeholder="Enter a System.Double">
    <Entry.Behaviors>
        <local:NumericValidationBehavior />
    </Entry.Behaviors>
</Entry>

Le contrôle Entry équivalent en C# est présenté dans l’exemple de code suivant :

var entry = new Entry { Placeholder = "Enter a System.Double" };
entry.Behaviors.Add (new NumericValidationBehavior ());

Lors de l’exécution, le comportement répond à l’interaction avec le contrôle en fonction de l’implémentation de comportement. Les captures d’écran suivantes illustrent le comportement répondant à une entrée non valide :

Exemple d’application avec Xamarin.Forms comportement

Remarque

Les comportements sont écrits pour un type de contrôle spécifique (ou une superclasse qui peut s’appliquer à de nombreux contrôles) et doivent être ajoutés à un contrôle compatible uniquement. La tentative d’attachement d’un comportement à un contrôle incompatible entraîne la levée d’une exception.

Consommation d’un Xamarin.Forms comportement avec un style

Les comportements peuvent aussi être consommés par un style explicite ou implicite. Toutefois, la création d’un style qui définit la propriété Behaviors d’un contrôle n’est pas possible parce que la propriété est en lecture seule. La solution consiste à ajouter une propriété attachée à la classe de comportement qui contrôle l’ajout et la suppression du comportement. Pour ce faire, procédez comme suit :

  1. Ajoutez une propriété attachée à la classe de comportement qui est utilisée pour contrôler l’ajout ou la suppression du comportement dans le contrôle auquel le comportement est attaché. Assurez-vous que la propriété attachée inscrit un délégué propertyChanged qui sera exécuté au changement de la valeur de la propriété.
  2. Créez une méthode getter ou setter static pour la propriété attachée.
  3. Dans le délégué propertyChanged, implémentez la logique qui ajoute ou supprime le comportement.

L’exemple de code suivant montre une propriété attachée qui contrôle l’ajout et la suppression de NumericValidationBehavior :

public class NumericValidationBehavior : Behavior<Entry>
{
    public static readonly BindableProperty AttachBehaviorProperty =
        BindableProperty.CreateAttached ("AttachBehavior", typeof(bool), typeof(NumericValidationBehavior), false, propertyChanged: OnAttachBehaviorChanged);

    public static bool GetAttachBehavior (BindableObject view)
    {
        return (bool)view.GetValue (AttachBehaviorProperty);
    }

    public static void SetAttachBehavior (BindableObject view, bool value)
    {
        view.SetValue (AttachBehaviorProperty, value);
    }

    static void OnAttachBehaviorChanged (BindableObject view, object oldValue, object newValue)
    {
        var entry = view as Entry;
        if (entry == null) {
            return;
        }

        bool attachBehavior = (bool)newValue;
        if (attachBehavior) {
            entry.Behaviors.Add (new NumericValidationBehavior ());
        } else {
            var toRemove = entry.Behaviors.FirstOrDefault (b => b is NumericValidationBehavior);
            if (toRemove != null) {
                entry.Behaviors.Remove (toRemove);
            }
        }
    }
    ...
}

La classe NumericValidationBehavior contient une propriété attachée nommée AttachBehavior avec une méthode getter ou setter static, qui contrôle l’ajout ou la suppression du comportement dans le contrôle auquel il est attaché. Cette propriété jointe inscrit la méthode OnAttachBehaviorChanged qui est exécutée au changement de la valeur de la propriété. Cette méthode ajoute ou supprime le comportement dans le contrôle en fonction de la valeur de la propriété attachée AttachBehavior.

L’exemple de code suivant montre un style explicite pour le NumericValidationBehavior qui utilise la propriété attachée AttachBehavior et qui peut être appliqué aux contrôles Entry :

<Style x:Key="NumericValidationStyle" TargetType="Entry">
    <Style.Setters>
        <Setter Property="local:NumericValidationBehavior.AttachBehavior" Value="true" />
    </Style.Setters>
</Style>

Le Style peut être appliqué à un contrôle Entry en définissant sa propriété Style sur l’instance Style à l’aide de l’extension de balisage StaticResource, comme illustré dans l’exemple de code suivant :

<Entry Placeholder="Enter a System.Double" Style="{StaticResource NumericValidationStyle}">

Pour plus d’informations sur les styles, consultez Styles.

Remarque

Vous pouvez ajouter des propriétés pouvant être liées à un comportement qui est défini ou interrogé en XAML, mais si vous créez des comportements qui ont un état, ceux-ci ne doivent pas être partagés entre les contrôles d’un Style dans un ResourceDictionary.

Suppression d’un comportement d’un contrôle

La méthode OnDetachingFrom est déclenchée quand un comportement est supprimé d’un contrôle et est utilisée pour effectuer tout nettoyage nécessaire, comme le désabonnement d’un événement pour empêcher une fuite de mémoire. Toutefois, les comportements ne sont pas supprimés implicitement des contrôles, sauf si la collection Behaviors du contrôle est modifiée par une méthode Remove ou Clear. L’exemple de code suivant illustre la suppression d’un comportement spécifique de la collection Behaviors d’un contrôle :

var toRemove = entry.Behaviors.FirstOrDefault (b => b is NumericValidationBehavior);
if (toRemove != null) {
    entry.Behaviors.Remove (toRemove);
}

Sinon, la collection Behaviors du contrôle peut être effacée, comme montré dans l’exemple de code suivant :

entry.Behaviors.Clear();

De plus, notez que les comportements ne sont pas supprimés implicitement des contrôles quand les pages sont dépilées de la pile de navigation. Ils doivent être explicitement supprimés avant que les pages ne soient hors de portée.

Résumé

Cet article a montré comment créer et consommer Xamarin.Forms des comportements. Xamarin.Formsles comportements sont créés en dérivant de la ou Behavior<T> de la Behavior classe.