Partager via

Xamarin.Forms Classe d’application

  • Article

La classe de base Application offre les fonctionnalités suivantes, qui sont exposées dans la sous-classe App par défaut de votre sous-projet :

  • Une propriété MainPage,dans laquelle définir la page initiale de l’application.
  • Un dictionnaire Properties persistant où stocker des valeurs simples lors des changements d’état de cycle de vie.
  • Une propriété Current qui contient une référence à l’objet d’application actuel.

Elle expose également les méthodes de cycle de vie comme OnStart, OnSleep et OnResume, ainsi que les événements de navigation modale.

Selon le modèle que vous avez choisi, la classe App peut être définie de deux manières :

  • C#
  • XAML et C#

Pour créer une classe App en XAML, vous devez remplacer la classe App par défaut par une classe App XAML et par le code-behind associé, comme indiqué dans l’exemple de code suivant :

<Application xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="Photos.App">

</Application>

L’exemple de code suivant montre le code-behind associé :

public partial class App : Application
{
    public App ()
    {
        InitializeComponent ();
        MainPage = new HomePage ();
    }
    ...
}

En plus de définir la propriété MainPage, le code-behind doit également appeler la méthode InitializeComponent pour charger et analyser le XAML associé.

Propriété MainPage

La propriété MainPage de la classe Application définit la page racine de l’application.

Par exemple, vous pouvez créer une logique dans votre classe App pour afficher une page différente selon que l’utilisateur est connecté ou non.

La propriété MainPage doit être définie dans le constructeur App.

public class App : Xamarin.Forms.Application
{
    public App ()
    {
        MainPage = new ContentPage { Title = "App Lifecycle Sample" }; // your page here
    }
}

Dictionnaire de propriétés

La sous-classe Application comprend un dictionnaire Properties statique qui peut être utilisé pour stocker des données, en particulier pour une utilisation dans les méthodes OnStart, OnSleep et OnResume. Vous pouvez y accéder n’importe où dans votre Xamarin.Forms code à l’aide Application.Current.Propertiesde .

Le dictionnaire Properties utilise une clé string et stocke une valeur object.

Par exemple, vous pouvez définir une propriété "id" persistante n’importe où dans votre code (lorsqu’un élément est sélectionné, dans la méthode OnDisappearing d’une page, ou dans la méthode OnSleep) de la façon suivante :

Application.Current.Properties ["id"] = someClass.ID;

Dans les méthodes OnStart ou OnResume, vous pouvez utiliser cette valeur pour recréer l’expérience utilisateur d’une certaine façon. Le dictionnaire Properties stocke des object. Vous devez donc caster sa valeur avant de l’utiliser.

if (Application.Current.Properties.ContainsKey("id"))
{
    var id = Application.Current.Properties ["id"] as int;
    // do something with id
}

Pour éviter toute erreur inattendue, vérifiez toujours la présence de la clé avant d’y accéder.

Remarque

Le dictionnaire Properties peut sérialiser uniquement les types primitifs de stockage. Les tentatives de stockage d’autres types (tels que List<string>) peuvent échouer silencieusement.

Persistance

Le dictionnaire Properties est automatiquement enregistré sur l’appareil. Les données ajoutées au dictionnaire seront disponibles lors du retour de l’application de l’arrière-plan ou après son redémarrage.

Xamarin.Forms 1.4 a introduit une méthode supplémentaire sur la Application classe , SavePropertiesAsync() qui peut être appelée pour conserver de manière proactive le Properties dictionnaire. Cela vous permet d’enregistrer les propriétés après les mises à jour importantes, plutôt que de risquer qu’elles ne soient pas sérialisées à cause d’un plantage ou parce qu’elles ont été tuées par le système d’exploitation.

Vous trouverez des références à l’utilisation du Properties dictionnaire dans le livre Creating Mobile Apps Xamarin.Forms(voir les chapitres 6, 15 et 20) et dans les exemples associés.

Classe d’application

L’implémentation complète de la classe Application est indiquée ci-dessous pour référence :

public class App : Xamarin.Forms.Application
{
    public App ()
    {
        MainPage = new ContentPage { Title = "App Lifecycle Sample" }; // your page here
    }

    protected override void OnStart()
    {
        // Handle when your app starts
        Debug.WriteLine ("OnStart");
    }

    protected override void OnSleep()
    {
        // Handle when your app sleeps
        Debug.WriteLine ("OnSleep");
    }

    protected override void OnResume()
    {
        // Handle when your app resumes
        Debug.WriteLine ("OnResume");
    }
}

Cette classe est ensuite instanciée dans chaque projet spécifique à la plateforme, puis passée à la méthode LoadApplication, où le MainPage est chargé et affiché à l’utilisateur. Le code adapté à chaque plateforme est indiqué dans les sections suivantes. Les derniers Xamarin.Forms modèles de solution contiennent déjà tout ce code, préconfigurés pour votre application.

Projet iOS

La classe AppDelegate iOS hérite de FormsApplicationDelegate. Elle doit :

  • Appeler LoadApplication avec une instance de la classe App

  • Toujours retourner base.FinishedLaunching (app, options);

[Register ("AppDelegate")]
public partial class AppDelegate :
    global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate // superclass new in 1.3
{
    public override bool FinishedLaunching (UIApplication app, NSDictionary options)
    {
        global::Xamarin.Forms.Forms.Init ();

        LoadApplication (new App ());  // method is new in 1.3

        return base.FinishedLaunching (app, options);
    }
}

Projet Android

Le MainActivity Android hérite de FormsAppCompatActivity. Dans le OnCreate, remplacez la méthode LoadApplication qui est appelée par une instance de la classe App.

[Activity (Label = "App Lifecycle Sample", Icon = "@drawable/icon", Theme = "@style/MainTheme", MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
public class MainActivity : FormsAppCompatActivity
{
    protected override void OnCreate (Bundle bundle)
    {
        base.OnCreate (bundle);

        global::Xamarin.Forms.Forms.Init (this, bundle);

        LoadApplication (new App ()); // method is new in 1.3
    }
}

Projet Windows universel (UWP) pour Windows 10

La page principale du projet UWP doit hériter de WindowsPage :

<forms:WindowsPage
   ...
   xmlns:forms="using:Xamarin.Forms.Platform.UWP"
   ...>
</forms:WindowsPage>

Le code C# derrière la construction doit appeler LoadApplication pour créer une instance de votre Xamarin.FormsApp. Notez qu’il est recommandé d’utiliser explicitement l’espace de noms de l’application pour qualifier le App , car les applications UWP ont également leur propre App classe non liée Xamarin.Forms.

public sealed partial class MainPage
{
    public MainPage()
    {
        InitializeComponent();

        LoadApplication(new YOUR_NAMESPACE.App());
    }
 }

Notez que Forms.Init() doit être appelé à partir d’App.xaml.cs dans le projet UWP.

Pour plus d’informations, consultez Configurer des projets Windows, qui inclut des étapes pour ajouter un projet UWP à une solution existante Xamarin.Forms qui ne cible pas UWP.

Retrouvez d’autres vidéos Xamarin sur Channel 9 et YouTube.