Freigeben über

Xamarin.Forms-App-Klasse

  • Artikel

Die Basisklasse Application bietet folgende Features, die in der Standard-App-Unterklasse Ihres Projekts verfügbar gemacht werden:

  • Eine MainPage-Eigenschaft, bei der die Startseite für die App festgelegt wird.
  • Ein beständiges Properties-Wörterbuch, in dem einfache Werte über Zustandsänderungen im Lebenszyklus hinweg gespeichert werden.
  • Eine statische Current-Eigenschaft, die einen Verweis auf das aktuelle Anwendungsobjekt enthält.

Es werden auch Lifecycle methods (Lebenszyklusmethoden) wie z.B. OnStart, OnSleep und OnResume sowie modale Navigationsereignisse verfügbar gemacht.

Je nachdem, welche Vorlage Sie ausgewählt haben, kann die App-Klasse auf eine von zwei Arten definiert werden:

  • C# oder
  • XAML & C#

Zum Erstellen einer App-Klasse mit XAML muss die Standard-App-Klasse durch eine XAML-App-Klasse und die dazugehörige CodeBehind-Datei ersetzt werden, wie im folgenden Codebeispiel gezeigt:

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

</Application>

Das folgende Codebeispiel zeigt das CodeBehind von :

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

Das CodeBehind muss sowohl die MainPage-Eigenschaft festlegen als auch die InitializeComponent-Methode aufrufen, um die zugehörige XAML zu laden und zu analysieren.

MainPage-Eigenschaft

Die MainPage-Eigenschaft der Application-Klasse legt die Stammseite der Anwendung fest.

Sie können zum Beispiel Logik in Ihrer App-Klasse erstellen, um unterschiedliche Seiten in Abhängigkeit davon anzuzeigen, ob der Benutzer angemeldet ist oder nicht.

Die MainPage-Eigenschaft sollte im App-Konstruktor festgelegt werden:

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

Eigenschaftenwörterbuch

Die Application-Unterklasse verfügt über ein statisches Properties-Wörterbuch, das zum Speichern von Daten verwendet werden kann, vor allem zur Verwendung in den Methoden OnStart, OnSleep und OnResume. Darauf kann von überall im Xamarin.Forms-Code mit Application.Current.Properties zugegriffen werden.

Das Properties-Wörterbuch verwendet einen string-Schlüssel und speichert einen object-Wert.

Sie könnten zum Beispiel eine beständige "id"-Eigenschaft an einer beliebigen Stelle im Code wie folgt festlegen (wenn ein Element ausgewählt wird in der Methode OnDisappearing einer Seite oder in der Methode OnSleep):

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

In den Methoden OnStart oder OnResume können Sie dann diesen Wert verwenden, um die Benutzeroberfläche auf gewisse Weise erneut zu erstellen. Das Properties-Wörterbuch speichert objecte, sodass Sie dessen Wert vor der Verwendung umwandeln müssen.

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

Überprüfen Sie immer, ob der Schlüssel vorhanden ist, bevor Sie darauf zugreifen, um unerwartete Fehler zu vermeiden.

Hinweis

Das Properties-Wörterbuch kann nur primitive Typen für die Speicherung serialisieren. Der Versuch, andere Typen (wie z.B. List<string>) zu speichern, kann im Hintergrund fehlschlagen.

Persistenz

Das Properties-Wörterbuch wird automatisch auf dem Gerät gespeichert. Daten, die dem Wörterbuch hinzugefügt werden, werden verfügbar, wenn die Anwendung aus dem Hintergrund zurückkehrt oder wenn sie neu gestartet wird.

Mit Xamarin.Forms 1.4 wurde die zusätzliche Methode SavePropertiesAsync() in der Application-Klasse eingeführt, die aufgerufen werden kann, um das Properties-Wörterbuch proaktiv beizubehalten. Dadurch können Sie Eigenschaften nach wichtigen Updates speichern anstatt zu riskieren, dass diese durch einen Absturz oder eine Löschung durch das Betriebssystem nicht serialisiert werden.

Sie finden Verweise auf die Verwendung des Properties Wörterbuchs in der Erstellung mobiler Apps mit Xamarin.FormsBuch (siehe Kapitel 6, 15 und 20) und in den zugehörigen Beispielen.

Die Anwendungsklasse

Eine vollständige Implementierung der Application-Klasse wird unten zur Referenz gezeigt:

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

Diese Klasse wird dann in jedem plattformspezifischen Projekt instanziiert und an die LoadApplication-Methode übergeben, wo die MainPage geladen und dem Benutzer angezeigt wird. Der Code für jede Plattform wird in den folgenden Abschnitten gezeigt. Die neuesten Vorlagen der Xamarin.Forms-Projektmappe enthalten bereits diesen gesamten Code, der für Ihre App vorkonfiguriert wurde.

iOS-Projekt

Die iOS-AppDelegate-Klasse erbt von FormsApplicationDelegate. Sie sollte

  • LoadApplication mit einer Instanz der App-Klasse aufrufen

  • immer base.FinishedLaunching (app, options); zurückgeben

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

Android-Projekt

Die Android-MainActivity-Klasse erbt von FormsAppCompatActivity. In der OnCreate-Überschreibung wird die LoadApplication-Methode mit einer Instanz der App-Klasse aufgerufen.

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

UWP-Projekt (Universelle Windows-Plattform) für Windows 10

Die Hauptseite im UWP-Projekt sollte von WindowsPage erben:

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

Der C#-Code hinter der Konstruktion muss aufgerufen LoadApplication werden, um eine Instanz Ihrer Xamarin.FormsApp. Beachten Sie, dass es sich empfiehlt, explizit den Anwendungsnamespace zu verwenden, um die App-Klasse zu kennzeichnen, da UWP-Anwendungen auch über eine eigene, von Xamarin.Forms unabhängige App-Klasse verfügen.

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

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

Beachten Sie, dass Forms.Init() von App.xaml.cs im UWP-Projekt abgerufen werden muss.

Weitere Informationen finden Sie unter Einrichten von Windows-Projekten. In diesem Artikel werden Schritte zum Hinzufügen eines UWP-Projekts zu einer vorhandenen Xamarin.Forms-Lösung erläutert, die nicht auf UWP abzielt.

Auf Channel 9 und auf YouTube finden Sie weitere Videos zu Xamarin.