Partager via

EffectBehavior réutilisable

  • Article

Les comportements constituent une approche utile pour ajouter un effet à un contrôle, en supprimant des fichiers code-behind le code réutilisable qui gère les effets. Cet article montre comment créer et consommer un Xamarin.Forms comportement pour ajouter un effet à un contrôle.

Vue d’ensemble

La EffectBehavior classe est un comportement personnalisé réutilisable Xamarin.Forms qui ajoute une Effect instance à un contrôle lorsque le comportement est attaché au contrôle et supprime l’instance Effect lorsque le comportement est détaché du contrôle.

Les propriétés de comportement suivantes doivent être définies pour utiliser le comportement :

  • Group – valeur de l’attribut ResolutionGroupName pour la classe de l’effet.
  • Name – valeur de l’attribut ExportEffect pour la classe de l’effet.

Pour plus d’informations sur les effets, consultez Effets.

Remarque

Il EffectBehavior s’agit d’une classe personnalisée qui peut être située dans l’exemple et qui ne fait pas partie de Xamarin.Forms.

Création du comportement

La classe EffectBehavior dérive de la classe Behavior<T>, où T est une View. Cela signifie que la EffectBehavior classe peut être attachée à n’importe quel Xamarin.Forms contrôle.

Implémentation des propriétés pouvant être liées

La classe EffectBehavior définit deux instances BindableProperty, qui sont utilisées pour ajouter un Effect à un contrôle quand le comportement est attaché au contrôle. Ces propriétés sont présentées dans l’exemple de code suivant :

public class EffectBehavior : Behavior<View>
{
  public static readonly BindableProperty GroupProperty =
    BindableProperty.Create ("Group", typeof(string), typeof(EffectBehavior), null);
  public static readonly BindableProperty NameProperty =
    BindableProperty.Create ("Name", typeof(string), typeof(EffectBehavior), null);

  public string Group {
    get { return (string)GetValue (GroupProperty); }
    set { SetValue (GroupProperty, value); }
  }

  public string Name {
    get { return(string)GetValue (NameProperty); }
    set { SetValue (NameProperty, value); }
  }
  ...
}

Quand l’EffectBehavior est consommé, la propriété Group doit être définie avec la valeur de l’attribut ResolutionGroupName de l’effet. De plus, la propriété Name doit être définie avec la valeur de l’attribut ExportEffect de la classe de l’effet.

Implémentation des remplacements

La classe EffectBehavior remplace les méthodes OnAttachedTo et OnDetachingFrom de la classe Behavior<T>, comme illustré dans l’exemple de code suivant :

public class EffectBehavior : Behavior<View>
{
  ...
  protected override void OnAttachedTo (BindableObject bindable)
  {
    base.OnAttachedTo (bindable);
    AddEffect (bindable as View);
  }

  protected override void OnDetachingFrom (BindableObject bindable)
  {
    RemoveEffect (bindable as View);
    base.OnDetachingFrom (bindable);
  }
  ...
}

La méthode OnAttachedTo effectue la configuration en appelant la méthode AddEffect pour passer le contrôle attaché en tant que paramètre. La méthode OnDetachingFrom effectue le nettoyage en appelant la méthode RemoveEffect pour passer le contrôle attaché en tant que paramètre.

Implémentation de la fonctionnalité de comportement

L’objectif du comportement consiste à ajouter l’Effect défini dans les propriétés Group et Name à un contrôle quand le comportement est attaché au contrôle et à supprimer l’Effect quand le comportement est détaché du contrôle. La fonctionnalité de comportement clé est illustrée dans l’exemple de code suivant :

public class EffectBehavior : Behavior<View>
{
  ...
  void AddEffect (View view)
  {
    var effect = GetEffect ();
    if (effect != null) {
      view.Effects.Add (GetEffect ());
    }
  }

  void RemoveEffect (View view)
  {
    var effect = GetEffect ();
    if (effect != null) {
      view.Effects.Remove (GetEffect ());
    }
  }

  Effect GetEffect ()
  {
    if (!string.IsNullOrWhiteSpace (Group) && !string.IsNullOrWhiteSpace (Name)) {
      return Effect.Resolve (string.Format ("{0}.{1}", Group, Name));
    }
    return null;
  }
}

La méthode AddEffect est exécutée en réponse à l’attachement de l’EffectBehavior à un contrôle et reçoit le contrôle attaché en tant que paramètre. La méthode ajoute ensuite l’effet récupéré à la collection Effects du contrôle. La méthode RemoveEffect est exécutée en réponse au détachement de l’EffectBehavior d’un contrôle et reçoit le contrôle détaché en tant que paramètre. La méthode supprime ensuite l’effet de la collection Effects du contrôle.

La méthode GetEffect utilise la méthode Effect.Resolve pour récupérer l’Effect. L’effet se trouve dans une concaténation des valeurs de la propriété Group et Name. Si une plateforme ne fournit pas l’effet, la méthode Effect.Resolve retourne une valeur non null.

Consommation du comportement

La classe EffectBehavior peut être attachée à la collection Behaviors d’un contrôle, comme illustré dans l’exemple de code XAML suivant :

<Label Text="Label Shadow Effect" ...>
  <Label.Behaviors>
    <local:EffectBehavior Group="Xamarin" Name="LabelShadowEffect" />
  </Label.Behaviors>
</Label>

Le code C# équivalent est affiché dans l’exemple de code suivant :

var label = new Label {
  Text = "Label Shadow Effect",
  ...
};
label.Behaviors.Add (new EffectBehavior {
  Group = "Xamarin",
  Name = "LabelShadowEffect"
});

Les propriétés Group et Name du comportement sont définies avec les valeurs des attributs ResolutionGroupName et ExportEffect de la classe de l’effet dans chaque projet spécifique à une plateforme.

Lors de l’exécution, quand le comportement est attaché au contrôle Label, le Xamarin.LabelShadowEffect est ajouté à la collection Effects du contrôle. Il en résulte l’ajout d’une ombre au texte affiché par le contrôle Label, comme illustré dans les captures d’écran suivantes :

Exemple d’application avec EffectsBehavior

L’avantage d’utiliser ce comportement pour ajouter et supprimer des effets dans des contrôles est que le code réutilisable qui gère les effets peut être supprimé des fichiers code-behind.

Résumé

Cet article a décrit l’utilisation d’un comportement pour ajouter un effet à un contrôle. La EffectBehavior classe est un comportement personnalisé réutilisable Xamarin.Forms qui ajoute une Effect instance à un contrôle lorsque le comportement est attaché au contrôle et supprime l’instance Effect lorsque le comportement est détaché du contrôle.