EffectBehavior reutilizávelReusable EffectBehavior

Baixar Exemplo Baixar o exemploDownload Sample Download the sample

Os comportamentos são uma abordagem útil para adicionar um efeito a um controle, removendo o código de manipulação de efeito de placa de apoio dos arquivos code-behind. Este artigo demonstra como criar e consumir um Xamarin.Forms comportamento para adicionar um efeito a um controle.Behaviors are a useful approach for adding an effect to a control, removing boiler-plate effect handling code from code-behind files. This article demonstrates creating and consuming a Xamarin.Forms behavior to add an effect to a control.

Visão geralOverview

A EffectBehavior classe é um comportamento personalizado reutilizável Xamarin.Forms que adiciona uma Effect instância a um controle quando o comportamento é anexado ao controle e remove a Effect instância quando o comportamento é desanexado do controle.The EffectBehavior class is a reusable Xamarin.Forms custom behavior that adds an Effect instance to a control when the behavior is attached to the control, and removes the Effect instance when the behavior is detached from the control.

As seguintes propriedades de comportamento precisam ser definidas para que o comportamento seja usado:The following behavior properties must be set to use the behavior:

Para obter mais informações sobre efeitos, confira Efeitos.For more information about effects, see Effects.

Observação

O EffectBehavior é uma classe personalizada que pode ser localizada no exemplo de comportamento de efeitoe não faz parte do Xamarin.Forms .The EffectBehavior is a custom class that can be located in the Effect Behavior sample, and is not part of Xamarin.Forms.

Criação do comportamentoCreating the Behavior

A EffectBehavior classe deriva da Behavior<T> classe, onde T é um View .The EffectBehavior class derives from the Behavior<T> class, where T is a View. Isso significa que a EffectBehavior classe pode ser anexada a qualquer Xamarin.Forms controle.This means that the EffectBehavior class can be attached to any Xamarin.Forms control.

Implementação de propriedades associáveisImplementing Bindable Properties

A EffectBehavior classe define duas BindableProperty instâncias, que são usadas para adicionar um Effect a um controle quando o comportamento é anexado ao controle.The EffectBehavior class defines two BindableProperty instances, which are used to add an Effect to a control when the behavior is attached to the control. Essas propriedades são mostradas no seguinte exemplo de código:These properties are shown in the following code example:

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); }
  }
  ...
}

Quando o EffectBehavior for consumido, a Group Propriedade deverá ser definida como o valor do ResolutionGroupName atributo para o efeito.When the EffectBehavior is consumed, the Group property should be set to the value of the ResolutionGroupName attribute for the effect. Além disso, a Name propriedade deve ser definida como o valor do ExportEffect atributo para a classe Effect.In addition, the Name property should be set to the value of the ExportEffect attribute for the effect class.

Implementação de substituiçõesImplementing the Overrides

A EffectBehavior classe substitui o [ OnAttachedTo ] (xref: Xamarin.Forms . Comportamento 1.OnAttachedTo(Xamarin.Forms.BindableObject)) and [ OnDetachingFrom ](xref:Xamarin.Forms.Behavior 1. OnDetachingFrom ( Xamarin.Forms . Bindobject)) da Behavior<T> classe, conforme mostrado no exemplo de código a seguir:The EffectBehavior class overrides the OnAttachedTo and OnDetachingFrom methods of the Behavior<T> class, as shown in the following code example:

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);
  }
  ...
}

O [ OnAttachedTo ] (xref: Xamarin.Forms . Comportamento 1.OnAttachedTo(Xamarin.Forms.BindableObject)) method performs setup by calling the addeffect method, passing in the attached control as a parameter. The [ OnDetachingFrom ](xref:Xamarin.Forms.Behavior 1. OnDetachingFrom ( Xamarin.Forms . Acopláobject)) executa a limpeza chamando o RemoveEffect método, passando o controle anexado como um parâmetro.The OnAttachedTo method performs setup by calling the AddEffect method, passing in the attached control as a parameter. The OnDetachingFrom method performs cleanup by calling the RemoveEffect method, passing in the attached control as a parameter.

Implementação da funcionalidade de comportamentoImplementing the Behavior Functionality

A finalidade do comportamento é adicionar o Effect definido nas Group Name Propriedades e a um controle quando o comportamento é anexado ao controle e remover o Effect quando o comportamento é desanexado do controle.The purpose of the behavior is to add the Effect defined in the Group and Name properties to a control when the behavior is attached to the control, and remove the Effect when the behavior is detached from the control. A principal funcionalidade de comportamento é mostrada no seguinte exemplo de código:The core behavior functionality is shown in the following code example:

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;
  }
}

O método AddEffect é executado em resposta ao EffectBehavior ser anexado a um controle e ele recebe o controle anexado como um parâmetro.The AddEffect method is executed in response to the EffectBehavior being attached to a control, and it receives the attached control as a parameter. O método, em seguida, adiciona o efeito recuperado à Effects coleção do controle.The method then adds the retrieved effect to the control's Effects collection. O método RemoveEffect é executado em resposta ao EffectBehavior ser desanexado de um controle e ele recebe o controle anexado como um parâmetro.The RemoveEffect method is executed in response to the EffectBehavior being detached from a control, and it receives the attached control as a parameter. O método, em seguida, remove o efeito da Effects coleção do controle.The method then removes the effect from the control's Effects collection.

O GetEffect método usa o Effect.Resolve método para recuperar o Effect .The GetEffect method uses the Effect.Resolve method to retrieve the Effect. O efeito é localizado por meio de uma concatenação dos valores de propriedade Group e Name.The effect is located through a concatenation of the Group and Name property values. Se uma plataforma não fornecer o efeito, o método Effect.Resolve retornará um valor não null.If a platform doesn't provide the effect, the Effect.Resolve method will return a non-null value.

Consumo do comportamentoConsuming the Behavior

A EffectBehavior classe pode ser anexada à Behaviors coleção de um controle, conforme demonstrado no exemplo de código XAML a seguir:The EffectBehavior class can be attached to the Behaviors collection of a control, as demonstrated in the following XAML code example:

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

O código C# equivalente é mostrado no exemplo de código a seguir:The equivalent C# code is shown in the following code example:

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

As Group Name Propriedades e do comportamento são definidas para os valores dos ResolutionGroupName atributos e da ExportEffect classe Effect em cada projeto específico da plataforma.The Group and Name properties of the behavior are set to the values of the ResolutionGroupName and ExportEffect attributes for the effect class in each platform-specific project.

Em tempo de execução, quando o comportamento é anexado ao Label controle, o Xamarin.LabelShadowEffect será adicionado à coleção do controle Effects .At runtime, when the behavior is attached to the Label control, the Xamarin.LabelShadowEffect will be added to the control's Effects collection. Isso faz com que uma sombra seja adicionada ao texto exibido pelo controle Label, conforme mostrado nas capturas de tela seguir:This results in a shadow being added to the text displayed by the Label control, as shown in the following screenshots:

Aplicativo de exemplo com EffectsBehavior

A vantagem de usar esse comportamento para adicionar e remover efeitos de controles é que o código de manipulação de efeito clichê pode ser removido de arquivos code-behind.The advantage of using this behavior to add and remove effects from controls is that boiler-plate effect-handling code can be removed from code-behind files.

ResumoSummary

Este artigo demonstrou o uso de um comportamento para adicionar um efeito a um controle.This article demonstrated using a behavior to add an effect to a control. A EffectBehavior classe é um comportamento personalizado reutilizável Xamarin.Forms que adiciona uma Effect instância a um controle quando o comportamento é anexado ao controle e remove a Effect instância quando o comportamento é desanexado do controle.The EffectBehavior class is a reusable Xamarin.Forms custom behavior that adds an Effect instance to a control when the behavior is attached to the control, and removes the Effect instance when the behavior is detached from the control.