Xamarin forms est un framework qui vous permet de développer des interfaces de manière identique sur les 3 plateformes mobiles. Regardons comment cela fonctionne.

Xamarin Forms

Quand vous créez un projet Xamarin Forms, vous créez en réalité 4 projets : un pour chaque plateforme et un pour le code partagé. Pour ce quatrième projet, vous avez le choix entre Shared Code et portable class.

La PCL (Portable Class Library) est la même que celle initiée par Microsoft. Elle est compatible avec des projets de type Android et IOS.

Le projet Shared Code est en fait une façon de partager du code à travers plusieurs projets qui ne ciblent pas la même plateforme. Ce mode est l’équivalent d’un lien symbolique de fichiers dans différents projets. Vous allez pouvoir utiliser des directives de compilation pour customiser le code en fonction de la plateforme.

Les trois autres projets sont des bootstraps pour Xamarin Forms. Ils contiennent du code qui référence la première page Forms de votre application. Cette page est transformée, à l’exécution, dans le format de chaque plateforme.

Implémentation du pattern MVVM

Le Template de base donne le code de votre vue en c#, mais rien ne vous empêche de l’écrire en Xaml. Ensuite, il faut que votre vue référence votre ViewModel :

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
					   xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:vm="clr-namespace:AlloWorld.Forms.Vm;assembly=AlloWorld.Forms"
					   x:Class="AlloWorld.Forms.MainPage">
  <ContentPage.BindingContext>
    <vm:MainPageViewModel />
  </ContentPage.BindingContext>
  <StackLayout>
...
  </StackLayout>
</ContentPage>

Vous avez votre projet de démarrage avec le pattern MVVM.

Où est passé le Navigation Service ?

Pour utiliser le navigation service, il vous faut utiliser le contrôle navigationPage.

Celui-ci se comportera de manière différente suivant la plateforme. En Windows Phone, c’est le contrôle de navigation de page classique.

Le Navigation Service est disponible seulement côté vue, or je voudrais l’utiliser côté ViewModel. Comment faire ? Simplement en initialisant une interface avec une propriété initialisée par la navigation.

Je vous propose un petit bout de code pour récupérer l’instance d’une page avec le bon ViewModel:

public static Page GetPage<TPageTViewModel>()
    where TPage : Pagenew()
    where TViewModel : BaseViewModelnew()
{
    var view = new TPage();
    var vm = new TViewModel();
    view.BindingContext = vm;
    vm.Navigation = view.Navigation;
 
    return view;
}

Ensuite, nos Xaml seront des pages. Puis, dans le ViewModel, il suffit de faire un PushAsync de notre page sur le Navigation service.

this.Navigation.PushAsync(App.GetPage<AboutPageAboutViewModel>());

Et les RelayCommand ?

Là-dessus tous est prévu. Xamarin Forms vient avec ses propres Command :

public ICommand SendCommand {
    get
    {
        return new Command(
            () =>
                {
...
                });
    }
}

Elles ont le même comportement que les RelayCommand de nos frameworks préférés. On pourra les binder de la même manière.

Oui mais mes applications n’ont pas le même rendu.

Lorsque vos applications n’ont pas le même rendu selon la ou les plateformes ciblées, il existe différentes techniques.

Le OnPlatform

Magie de la technique, il est possible de faire disparaître, changer les marges, etc, en fonction de la plateforme et ce grâce à un bout de code Xaml.

    <Button Text="Save" Command="{Binding SendCommand}">
      <Button.IsVisible>
        <OnPlatform x:TypeArguments="system:Boolean" Android="true" WinPhone="false" iOS="true" />
      </Button.IsVisible>
    </Button>

Celui-ci permet, par exemple, de gérer la barre d’action de Windows Phone et d’afficher des boutons dans le cas d’Android.

  <StackLayout>
    <Editor Text="{Binding Message}" />
    <Button Text="Save" Command="{Binding SendCommand}">
      <Button.IsVisible>
        <OnPlatform x:TypeArguments="system:Boolean" Android="true" WinPhone="false" iOS="true" />
      </Button.IsVisible>
    </Button>
  </StackLayout>
  <ContentPage.ToolbarItems>
    <ToolbarItem Name="Save" Command="{Binding SendCommand}" />
  </ContentPage.ToolbarItems>

Injection de dépendances (dependency injection)

Décidément, Xamarin a pensé à tout. Ils nous proposent de faire de l’injection de dépendances avec

var dialService = DependencyService.Get<IDialService>();

Puis de référencer l’implémentation spécifique dans chaque projet :

[assembly: Xamarin.Forms.Dependency(typeof(DialService))]

J’adore MVVM Light, ça ne va pas marcher ?

La communauté .Net se met à Xamarin. Différents projets sont compatibles Xamarin, et MVVM Light en fait partie.

http://blog.galasoft.ch/posts/2014/09/getting-ready-for-xamarin-evolve/

Conclusion

Beaucoup d’efforts sont faits de la part de Xamarin et la communauté. Xamarin Forms n’est qu’aux prémices de ses capacités. Tout cela est très prometteur.

Livre Blanc Cell'insight 5 Xamarin