[Xamarin Forms] Nouveautés indispensables pour le développeur XAML

En tant que développeur XAML depuis plusieurs années, j’ai pour habitude de m’adapter aux changements successifs apportés à chaque plateforme de ce langage.

Lors de l’apparition de Xamarin Forms, j’ai tout de suite été emballé en me disant que j’allais pouvoir tirer partie de mes connaissances pour développer des interfaces natives et multiplateformes.

Mes premiers tests lors de l’annonce de Xamarin Forms n’ont été guère concluants. Les débuts étaient prometteurs, passionnants, motivants mais avec tout le pragmatisme qui doit être de mise lorsque l’on recommande un produit à un client, ils ne m’ont pas permis de le voir comme une solution viable de développement multiplateformes à ce moment- là.

J’ai donc continué, pendant les quelques mois qui ont suivi, à recommander un développement en Xamarin classique en développant donc 3 fois l’interface graphique mais en partageant un maximum de logique métier dans des Portable Class Librairies.

Avec Xamarin Forms 1.3, cette première impression a beaucoup évolué.

Les nouveautés de Xamarin Forms 1.3

Les Styles

Il est difficile d’imaginer développer une application XAML sans le support des styles et c’est un des gros manques de Xamarin Forms pré 1.3. Après quelques longs mois d’attente, Xamarin a enfin comblé ce manque et ce qu’il faut dire c’est qu’il n’y a ici aucune surprise pour le développeur XAML.

Voici comment définir un style :

<Style x:Key="GreenLabelStyle" TargetType="Label">
  <Setter Property="TextColor" Value="Green" />
</Style>

Il est intéressant de noter que les styles dans Xamarin supportent aussi les styles implicites et l’héritage des styles.

<Style x:Key="RedLabelStyle" TargetType="Label" BasedOn="{StaticResource GreenLabelStyle}">
  <Setter Property="TextColor" Value="Red" />
</Style>

<Style TargetType="Label" BasedOn="{StaticResource RedLabelStyle}"/>

Ressources dynamiques

A l’image de ce qui existe en WPF et qui n’a jamais été porté sur les autres plateformes XAML, les ressources dynamiques sont à utiliser lorsque la valeur d’une ressource évolue dans le temps. On s’était habitué à la perte de cette fonctionnalité qui finalement se montrait assez peu utile.

L’arrivée de iOS 8 et de son support des types dynamiques (permettant entre autres de modifier les fonctions d’accessibilité du téléphone) a justifié la réintroduction de ce concept ce qui nous permet de coller encore plus à la plateforme.

<Label Text="Mon label dynamique" Style="{DynamicResource TitleStyle}"/>

Triggers

Tombés en désuétude suite aux évolutions des différentes plateformes XAML, ils renaissent de leurs cendres avec Xamarin Forms.
Les développeurs WPF se sentiront plutôt à l’aise avec ce concept et la syntaxe retenue par Xamarin. L’idée d’un trigger est d’exécuter une action suite à un événement ou à une modification de la valeur d’une propriété. On s’en sert généralement pour changer l’apparence d’un élément comme la couleur d’un Label ou d’un Button.

A titre personnel, je préfère le principe de VisualStates qui avaient été intégré dans XAML à partir de Silverlight. Toutefois, ils représentent un grand pas en avant.

<Style x:Key="CustomButtonStyle" TargetType="Button">
  <Setter Property="TextColor" Value="White"/>
  <Setter Property="BackgroundColor" Value="Blue"/>
  <Setter Property="BorderColor" Value="Transparent"/>
  <Style.Triggers>
    <Trigger Property="IsEnabled" Value="False" TargetType="Button">
      <Setter Property="BackgroundColor" Value="Gray"/>
      <Setter Property="TextColor" Value="Silver"/>
    </Trigger>
  </Style.Triggers>
</Style>

Behaviors

Les Behaviors sont grossièrement des morceaux de code-behind réutilisables dans différentes vues que l’on attache à des éléments graphiques. On s’en sert énormément lorsque l’on fait du MVVM pour faire des ponts entre certains événements de la vue et le View Model. Il suffit de surclasser la classe de base Behavior<T> où T est le type du contrôle sur lequel on attache le Behavior.
Ici, j’ai pris l’exemple de l’exécution d’une commande du View Model suite au changement de sélection d’une ListView.

public class ListViewSelectionChangedToCommandBehavior : Behavior<ListView>
{
    public static readonly BindableProperty CommandProperty =
        BindableProperty.Create<ListViewSelectionChangedToCommandBehavior, Command>(p => p.Command, default(Command));

    public Command Command
    {
        get { return (Command)GetValue(CommandProperty); }
        set { SetValue(CommandProperty, value); }
    }

    protected override void OnAttachedTo(ListView listView)
    {
        base.OnAttachedTo(listView);

        listView.ItemSelected += ListViewOnItemSelected;
    }

    protected override void OnDetachingFrom(ListView listView)
    {
        listView.ItemSelected -= ListViewOnItemSelected;

        base.OnDetachingFrom(listView);
    }

    private void ListViewOnItemSelected(object sender, SelectedItemChangedEventArgs args)
    {
        var listView = (ListView) sender;
        var command = Command;
        if (command == null)
            return;

        if (command.CanExecute(args.SelectedItem))
            command.Execute(args.SelectedItem);
        listView.SelectedItem = null;
    }
}

<ListView ItemsSource="{Binding ItemList}">
  <ListView.Behaviors>
    <behaviors:ListViewSelectionChangedToCommandBehavior Command="{Binding ShowDetailCommand, Source={x:Static viewModels:ViewModelLocator.MasterPageViewModel}}"/>
  </ListView.Behaviors>
  <ListView.ItemTemplate>
    <DataTemplate>
      <TextCell Text="{Binding Name}"/>
    </DataTemplate>
  </ListView.ItemTemplate>
</ListView>

Conclusion

Xamarin Forms s’est enrichi, dans sa version 1.3, de fonctionnalités chères aux développeurs XAML : les Styles, les Triggers, les Behaviors ou encore les dictionnaires de ressources globaux. Bien d’autres fonctionnalités moins liées aux XAML ont été rajoutées telle que l’amélioration de la gestion du cycle de vie ou une meilleure prise en charge des polices d’écriture.

Beaucoup de bugs ont été corrigés et  les promesses offertes par Xamarin Forms seront tenues à la condition bien sûr de savoir comment s’y prendre et surtout en l’utilisant dans les cas où il est le plus approprié.

Il reste cependant encore beaucoup de petits défauts de jeunesse et quelques comportements inattendus pour un développeur XAML habitué aux plateformes Microsoft.

N’oubliez cependant pas que Xamarin évolue tous les jours et que tous ces petits soucis seront très rapidement corrigés !

C’est donc une plateforme de développement à suivre !