Criar Xamarin.Forms comportamentosCreate Xamarin.Forms behaviors

Baixar Exemplo Baixar o exemploDownload Sample Download the sample

Xamarin.Forms os comportamentos são criados pela derivação da classe de comportamento ou comportamento < T > . Este artigo demonstra como criar e consumir Xamarin.Forms comportamentos.Xamarin.Forms behaviors are created by deriving from the Behavior or Behavior<T> class. This article demonstrates how to create and consume Xamarin.Forms behaviors.

Visão geralOverview

O processo de criação de um Xamarin.Forms comportamento é o seguinte:The process for creating a Xamarin.Forms behavior is as follows:

  1. Crie uma classe que herda da Behavior classe ou Behavior<T> , em que T é o tipo do controle ao qual o comportamento deve ser aplicado.Create a class that inherits from the Behavior or Behavior<T> class, where T is the type of the control to which the behavior should apply.
  2. Substitua o [ OnAttachedTo ] (xref: Xamarin.Forms . Behavior'1. onanexadoto ( Xamarin.Forms . Bindobject)) para executar qualquer configuração necessária.Override the OnAttachedTo method to perform any required setup.
  3. Substitua o [ OnDetachingFrom ] (xref: Xamarin.Forms . Behavior'1. OnDetachingFrom ( Xamarin.Forms . Bindobject)) para executar qualquer limpeza necessária.Override the OnDetachingFrom method to perform any required cleanup.
  4. Implementar a funcionalidade principal do comportamento.Implement the core functionality of the behavior.

Isso resulta na estrutura mostrada no exemplo de código a seguir:This results in the structure shown in the following code example:

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
}

O [ OnAttachedTo ] (xref: Xamarin.Forms . Behavior'1. onanexadoto ( Xamarin.Forms . Acopláobject)) é acionado imediatamente após o comportamento ser anexado a um controle.The OnAttachedTo method is fired immediately after the behavior is attached to a control. Esse método recebe uma referência ao controle ao qual ele está anexado e pode ser usado para registrar manipuladores de eventos ou para realizar outra configuração necessária para dar suporte à funcionalidade do comportamento.This method receives a reference to the control to which it is attached, and can be used to register event handlers or perform other setup that's required to support the behavior functionality. Por exemplo, você pode assinar um evento em um controle.For example, you could subscribe to an event on a control. A funcionalidade do comportamento, então, seria implementada no manipulador do evento.The behavior functionality would then be implemented in the event handler for the event.

O [ OnDetachingFrom ] (xref: Xamarin.Forms . Behavior'1. OnDetachingFrom ( Xamarin.Forms . Acopláobject)) é acionado quando o comportamento é removido do controle.The OnDetachingFrom method is fired when the behavior is removed from the control. Esse método recebe uma referência ao controle ao qual ele está anexado e é usado para executar qualquer limpeza necessária.This method receives a reference to the control to which it is attached, and is used to perform any required cleanup. Por exemplo, você poderia cancelar a assinatura de um evento em um controle para evitar perdas de memória.For example, you could unsubscribe from an event on a control to prevent memory leaks.

O comportamento pode então ser consumido anexando-o à Behaviors coleção do controle apropriado.The behavior can then be consumed by attaching it to the Behaviors collection of the appropriate control.

Criando um Xamarin.Forms comportamentoCreating a Xamarin.Forms Behavior

O aplicativo de exemplo demonstra um NumericValidationBehavior , que realça o valor inserido pelo usuário em um Entry controle em vermelho, se não for um double .The sample application demonstrates a NumericValidationBehavior, which highlights the value entered by the user into an Entry control in red, if it's not a double. Esse comportamento é mostrado no exemplo de código a seguir:The behavior is shown in the following code example:

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

O NumericValidationBehavior deriva da Behavior<T> classe, em que T é um Entry .The NumericValidationBehavior derives from the Behavior<T> class, where T is an Entry. O [ OnAttachedTo ] (xref: Xamarin.Forms . Comportamento 1.OnAttachedTo(Xamarin.Forms.BindableObject)) method registers an event handler for the [ TextChanged ](xref:Xamarin.Forms.InputView.TextChanged) event, with the [ OnDetachingFrom ](xref:Xamarin.Forms.Behavior 1. OnDetachingFrom ( Xamarin.Forms . Bindobject)) do método de registro do TextChanged evento para evitar vazamentos de memória.The OnAttachedTo method registers an event handler for the TextChanged event, with the OnDetachingFrom method de-registering the TextChanged event to prevent memory leaks. A funcionalidade principal do comportamento é fornecida pelo OnEntryTextChanged método, que analisa o valor inserido pelo usuário no Entry e define a TextColor propriedade como vermelha se o valor não for um double .The core functionality of the behavior is provided by the OnEntryTextChanged method, which parses the value entered by the user into the Entry, and sets the TextColor property to red if the value isn't a double.

Observação

Xamarin.Forms não define o BindingContext de um comportamento, porque os comportamentos podem ser compartilhados e aplicados a vários controles por meio de estilos.Xamarin.Forms does not set the BindingContext of a behavior, because behaviors can be shared and applied to multiple controls through styles.

Consumindo um Xamarin.Forms comportamentoConsuming a Xamarin.Forms Behavior

Cada Xamarin.Forms controle tem uma Behaviors coleção, à qual um ou mais comportamentos podem ser adicionados, conforme demonstrado no exemplo de código XAML a seguir:Every Xamarin.Forms control has a Behaviors collection, to which one or more behaviors can be added, as demonstrated in the following XAML code example:

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

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

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

Em runtime, o comportamento responderá à interação com o controle, de acordo com a implementação do comportamento.At runtime the behavior will respond to interaction with the control, according to the behavior implementation. As capturas de tela a seguir demonstram o comportamento respondendo a uma entrada inválida:The following screenshots demonstrate the behavior responding to invalid input:

Aplicativo de exemplo com::: no-Loc (Xamarin. Forms)::: BehaviorSample Application with Xamarin.Forms Behavior

Observação

Comportamentos são escritos para um tipo de controle específico (ou uma superclasse que pode ser aplicada a muitos controles) e só devem ser adicionados a um controle compatível.Behaviors are written for a specific control type (or a superclass that can apply to many controls), and they should only be added to a compatible control. Tentar anexar um comportamento a um controle incompatível fará com que uma exceção seja lançada.Attempting to attach a behavior to an incompatible control will result in an exception being thrown.

Consumindo um Xamarin.Forms comportamento com um estiloConsuming a Xamarin.Forms Behavior with a Style

Comportamentos também podem ser consumidos por um estilo explícito ou implícito.Behaviors can also be consumed by an explicit or implicit style. No entanto, não é possível criar um estilo que defina a Behaviors propriedade de um controle porque a propriedade é somente leitura.However, creating a style that sets the Behaviors property of a control is not possible because the property is read-only. A solução é adicionar uma propriedade anexada à classe do comportamento que controla a adição e a remoção do comportamento.The solution is to add an attached property to the behavior class that controls adding and removing the behavior. O processo é o seguinte:The process is as follows:

  1. Adicione uma propriedade anexada à classe do comportamento que será usado para controlar a adição ou remoção do comportamento do controle a que o comportamento será anexado.Add an attached property to the behavior class that will be used to control the addition or removal of the behavior to the control to which the behavior will attached. Certifique-se de que a propriedade anexada registre um delegado propertyChanged que será executado quando o valor da propriedade for alterado.Ensure that the attached property registers a propertyChanged delegate that will be executed when the value of the property changes.
  2. Crie um getter e setter static para a propriedade anexada.Create a static getter and setter for the attached property.
  3. Implemente a lógica no delegado propertyChanged para adicionar e remover o comportamento.Implement logic in the propertyChanged delegate to add and remove the behavior.

O exemplo de código a seguir mostra uma propriedade anexada que controla a adição e a remoção de NumericValidationBehavior:The following code example shows an attached property that controls adding and removing the 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);
            }
        }
    }
    ...
}

A classe NumericValidationBehavior contém uma propriedade anexada chamada AttachBehavior, com um getter e setter static, que controla a adição ou remoção do comportamento do controle a que ele será anexado.The NumericValidationBehavior class contains an attached property named AttachBehavior with a static getter and setter, which controls the addition or removal of the behavior to the control to which it will be attached. Essa propriedade anexada registra o método OnAttachBehaviorChanged que será executado quando o valor da propriedade for alterado.This attached property registers the OnAttachBehaviorChanged method that will be executed when the value of the property changes. Esse método adiciona ou remove o comportamento do controle com base no valor da propriedade anexada AttachBehavior.This method adds or removes the behavior to the control, based on the value of the AttachBehavior attached property.

O seguinte exemplo de código mostra um estilo explícito para o NumericValidationBehavior que usa a propriedade anexada AttachBehavior e que pode ser aplicado a controles Entry:The following code example shows an explicit style for the NumericValidationBehavior that uses the AttachBehavior attached property, and which can be applied to Entry controls:

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

O Style pode ser aplicado a um Entry controle definindo sua Style propriedade para a Style instância usando a StaticResource extensão de marcação, conforme demonstrado no exemplo de código a seguir:The Style can be applied to an Entry control by setting its Style property to the Style instance using the StaticResource markup extension, as demonstrated in the following code example:

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

Para mais informações sobre estilos, confira Estilos.For more information about styles, see Styles.

Observação

Embora seja possível adicionar propriedades vinculáveis a um comportamento definido ou consultado no XAML, se você criar comportamentos com estado, eles não deverão ser compartilhados entre os controles em um Style em um ResourceDictionary.While you can add bindable properties to a behavior that is set or queried in XAML, if you do create behaviors that have state they should not be shared between controls in a Style in a ResourceDictionary.

Removendo um comportamento de um controleRemoving a Behavior from a Control

O [ OnDetachingFrom ] (xref: Xamarin.Forms . Os 1.OnDetachingFrom(Xamarin.Forms.BindableObject)) method is fired when a behavior is removed from a control, and is used to perform any required cleanup such as unsubscribing from an event to prevent a memory leak. However, behaviors are not implicitly removed from controls unless the control's [ comportamentos de comportamento ](xref:Xamarin.Forms.VisualElement.Behaviors) collection is modified by a removem a or coleção de comportamentos claros method. The following code example demonstrates removing a specific behavior from a control's :The OnDetachingFrom method is fired when a behavior is removed from a control, and is used to perform any required cleanup such as unsubscribing from an event to prevent a memory leak. However, behaviors are not implicitly removed from controls unless the control's Behaviors collection is modified by a Remove or Clear method. The following code example demonstrates removing a specific behavior from a control's Behaviors\ collection:

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

Como alternativa, a coleção do controle Behaviors pode ser limpa, conforme demonstrado no exemplo de código a seguir:Alternatively, the control's Behaviors collection can be cleared, as demonstrated in the following code example:

entry.Behaviors.Clear();

Além disso, observe que os comportamentos não serão removidos implicitamente dos controles quando páginas forem removidas da pilha de navegação.In addition, note that behaviors are not implicitly removed from controls when pages are popped from the navigation stack. Em vez disso, eles devem ser removidos explicitamente antes que páginas saiam do escopo.Instead, they must be explicitly removed prior to pages going out of scope.

ResumoSummary

Este artigo demonstrou como criar e consumir Xamarin.Forms comportamentos.This article demonstrated how to create and consume Xamarin.Forms behaviors. Xamarin.Forms os comportamentos são criados pela derivação da Behavior Behavior<T> classe ou.Xamarin.Forms behaviors are created by deriving from the Behavior or Behavior<T> class.