Creare Xamarin.Forms comportamenti

Xamarin.Forms i comportamenti vengono creati derivando dalla classe Behavior o Behavior<T> . Questo articolo illustra come creare e utilizzare Xamarin.Forms comportamenti.

Panoramica

Il processo di creazione di un Xamarin.Forms comportamento è il seguente:

1. Creare una classe che erediti dalla classe Behavior o dalla classe Behavior<T>, dove T è il tipo di controllo al quale deve essere applicato il comportamento.
2. Eseguire l'override del metodo OnAttachedTo per eseguire le configurazioni richieste.
3. Eseguire l'override del metodo OnDetachingFrom per eseguire le operazioni di pulizia richieste.
4. Implementare le funzionalità principali del comportamento.

Il risultato è la struttura mostrata nell'esempio di codice seguente:

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
}

Il metodo OnAttachedTo viene attivato immediatamente non appena il comportamento è associato a un controllo. Questo metodo riceve un riferimento al controllo a cui è associato e può essere utilizzato per registrare i gestori eventi o per eseguire altre impostazioni necessarie per supportare la funzionalità del comportamento. Ad esempio, eseguire una sottoscrizione a un evento in un controllo. La funzionalità del comportamento verrebbe quindi implementata nel gestore eventi per l'evento.

Il metodo OnDetachingFrom viene attivato quando il comportamento viene rimosso dal controllo. Questo metodo riceve un riferimento al controllo a cui è associato e serve per eseguire le operazioni di pulizia necessarie. Ad esempio, annullare la sottoscrizione da un evento in un controllo per evitare perdite di memoria.

Il comportamento può quindi essere utilizzato associandolo alla raccolta Behaviors del controllo appropriato.

Creazione di un Xamarin.Forms comportamento

L'applicazione di esempio illustra un NumericValidationBehavior, che evidenzia in rosso il valore immesso dall'utente in un controllo Entry, se non ha valore double. Il comportamento è illustrato nell'esempio di codice riportato di seguito:

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 deriva dalla classe Behavior<T>, dove T è un controllo Entry. Il metodo OnAttachedTo registra un gestore eventi per l'evento TextChanged, con il metodo OnDetachingFrom che annulla la registrazione dell'evento TextChangedper evitare perdite di memoria. La funzionalità di base del comportamento è fornita dal metodo OnEntryTextChanged, che analizza il valore immesso dall'utente nel controllo Entry e imposta la proprietà TextColor su rosso se il valore non è double.

Nota

Xamarin.Forms non imposta l'oggetto BindingContext di un comportamento, perché i comportamenti possono essere condivisi e applicati a più controlli tramite stili.

Utilizzo di un Xamarin.Forms comportamento

Ogni Xamarin.Forms controllo ha una Behaviors raccolta, a cui è possibile aggiungere uno o più comportamenti, come illustrato nell'esempio di codice XAML seguente:

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

Il codice C# equivalente per Entry è visualizzato nell'esempio seguente:

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

In fase di esecuzione, il comportamento risponderà all'interazione con il controllo in base all'implementazione del comportamento. Gli screenshot seguenti illustrano il comportamento che risponde a input non valido:

Nota

I comportamenti vengono scritti per un tipo di controllo specifico, o per una superclasse che è possibile applicare a molti controlli, e devono essere aggiunti solo a controlli compatibili. Il tentativo di associare un comportamento a un controllo incompatibile comporta la generazione di un'eccezione.

Utilizzo di un Xamarin.Forms comportamento con uno stile

I comportamenti possono essere utilizzati anche da uno stile esplicito o implicito. Tuttavia, non è possibile creare uno stile che imposti la proprietà Behaviors di un controllo perché la proprietà è di sola lettura. La soluzione consiste nell'aggiungere una proprietà associata alla classe di comportamento che controlli l'aggiunta del comportamento o la sua rimozione. Passaggi del processo:

1. Aggiungere alla classe di comportamento una proprietà associata che verrà usata per controllare l'aggiunta del comportamento al controllo o la sua rimozione dal controllo a cui il comportamento verrà associato. Assicurarsi che la proprietà associata registri un delegato propertyChanged che verrà eseguito quando cambia il valore della proprietà.
2. Creare un getter e un setter static per la proprietà associata.
3. Implementare la logica nel delegato propertyChanged per aggiungere e rimuovere il comportamento.

L'esempio di codice seguente illustra una proprietà associata che controlla l'aggiunta e la rimozione di 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 contiene una proprietà associata denominata AttachBehavior con un getter e un setter static, che controlla l'aggiunta o la rimozione del comportamento del controllo a cui verrà associata. Tale proprietà associata registra il metodo OnAttachBehaviorChanged che verrà eseguito quando cambia il valore della proprietà. Questo metodo aggiunge il comportamento al controllo o lo rimuove da esso in base al valore della proprietà AttachBehavior associata.

L'esempio di codice riportato di seguito illustra uno stile esplicito per il NumericValidationBehavior che usa la proprietà associata AttachBehavior e che può essere applicato ai controlli Entry:

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

Style può essere applicato a un controllo Entry impostando la relativa proprietà Style sull'istanza di Style utilizzando l'estensione di markup StaticResource, come illustrato nell'esempio di codice seguente:

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

Per altre informazioni sugli stili, vedere Stili.

Nota

Sebbene sia possibile aggiungere proprietà associabili a un comportamento impostato o sottoposto a query in XAML, se si creano comportamenti con stato, questi non devono essere condivisi tra i controlli tramite uno Style in un oggetto ResourceDictionary.

Rimozione di un comportamento da un controllo

Il metodo OnDetachingFrom viene attivato quando un comportamento viene rimosso da un controllo e serve per eseguire le operazioni di pulizia necessarie, ad esempio annullare la sottoscrizione a un evento per impedire perdite di memoria. Tuttavia, i comportamenti non sono rimossi in modo implicito dai controlli, a meno che la raccolta Behaviors del controllo non sia modificata tramite un metodo Remove o Clear. L'esempio di codice seguente illustra come rimuovere un comportamento specifico da una raccolta Behaviors del controllo:

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

In alternativa, la raccolta Behaviors del controllo può essere cancellata, come illustrato nell'esempio di codice seguente:

entry.Behaviors.Clear();

Si noti inoltre che i comportamenti non vengono implicitamente rimossi dai controlli quando si estraggono le pagine dallo stack di navigazione. Devono pertanto essere rimossi esplicitamente prima che le pagine diventino esterne all'ambito.

Riepilogo

Questo articolo ha illustrato come creare e utilizzare Xamarin.Forms comportamenti. Xamarin.Forms i comportamenti vengono creati derivando dalla Behavior classe o Behavior<T> .

Collegamenti correlati

• Comportamento
• Behavior<T>