Teil 2: Verwalten von App-Lebenszyklus und -Zustand (Windows Store-Apps mit C#/VB und XAML)

Applies to Windows only

In Windows 8 können Sie eine Reihe von Apps starten und zwischen den einzelnen Apps wechseln, ohne befürchten zu müssen, das System dadurch zu verlangsamen oder den Akku schneller zu entladen. Der Grund: Im Hintergrund ausgeführte Apps werden vom System automatisch angehalten (und manchmal sogar beendet). Eine gute App kann vom System angehalten, beendet und neu gestartet werden und wirkt trotzdem immer so, als wäre sie ununterbrochen ausgeführt worden.

Wichtig  Dieses Lernprogramm ist für Microsoft Visual Studio 2013 und Windows 8.1 konzipiert. Teile des Lernprogramms funktionieren in Verbindung mit Microsoft Visual Studio 2012 und Windows 8 nicht ordnungsgemäß.

In diesem Lernprogramm lernen Sie Folgendes:

  • Speichern des Zustands mit unterschiedlichen Speicherarten
  • Wiederherstellen des App-Zustands beim nächsten Start der App

Vorbereitung

Informationen zum App-Lebenszyklus

Bevor Sie sich jedoch wieder dem Code zuwenden, beschäftigen wir uns erst einmal etwas mit dem Lebenszyklus der App. Die Aktivierung stellt den Beginn des App-Lebenszyklus dar. Eine App wird entweder nicht ausgeführt, ausgeführt oder wurde angehalten.

App-Lebenszyklus

Apps können angehalten werden, wenn der Benutzer die App verlässt oder Windows in einen Energiesparmodus wechselt. Angehaltene Apps verbleiben im Arbeitsspeicher, sodass Benutzer schnell und zuverlässig zwischen angehaltenen Apps wechseln und sie dadurch reaktivieren können. Für eine App, die angehalten und anschließend reaktiviert wird, ist kein zusätzlicher Code erforderlich, um den Eindruck zu erwecken, die Anwendung wäre ununterbrochen ausgeführt worden.

Windows kann angehaltene Apps aber auch jederzeit beenden, um Arbeitsspeicher für andere Apps freizugeben oder um Energie zu sparen. Eine beendete App wird nicht weiter ausgeführt und aus dem Arbeitsspeicher entladen.

Wenn der Benutzer eine App durch Drücken von ALT+F4 oder mit der Geste zum Schließen schließt, wird die App für 10 Sekunden angehalten und dann beendet.

Windows benachrichtigt Ihre App, wenn sie angehalten wird. Im Falle einer Beendigung erfolgt keine Benachrichtigung. Das bedeutet, Ihre App muss das Ereignis "Angehalten" behandeln und dabei ihren Zustand speichern sowie exklusive Ressourcen und Dateihandles sofort freigeben.

Um ein hohes Maß an Benutzerfreundlichkeit zu erreichen, soll der Eindruck entstehen, die App wäre ununterbrochen ausgeführt worden. Die App muss sämtliche vom Benutzer eingegebenen Daten sowie vom Benutzer geänderten Einstellungen und Ähnliches speichern. Dies bedeutet, dass Sie beim Anhalten der App den App-Zustand speichern müssen, damit Sie ihn später wiederherstellen können, sollte Windows die App beenden.

In Ihrer App müssen zwei Arten von Daten verwaltet werden: App-Daten und Sitzungsdaten.

In den folgenden Schritten erfahren Sie, wie die App aktualisiert wird, um diese Datentypen zu speichern. Welchen Zustand müssen Sie speichern? In der aktuellen Version kann der Benutzer lediglich den eingegebenen Namen ändern. Der Benutzer kann außerdem auf die Schaltfläche Say "Hello" klicken, um eine personalisierte Begrüßung zu generieren.

Schritt 1: Verwenden der SuspensionManager-Klasse

In Teil 1: Erstellen der App "Hello, world" haben Sie die MainPage-Standarddatei durch eine Datei ersetzt, die auf der Vorlage Standardseite basiert. Als Sie die Vorlage Standardseite angewendet haben, hat Microsoft Visual Studio dem Projekt im Ordner Common mehrere Dateien hinzugefügt. Eine dieser Dateien enthält die SuspensionManager-Klasse. SuspensionManager ist eine Hilfsklasse, mit der die Lebenszyklusverwaltung für die App vereinfacht wird. Die Klasse bietet folgende Vorteile: Sie speichert den Navigationszustand des Frames, der als Host für die App-Seiten fungiert, und stellt ihn wieder her. In einer App mit nur einer Seite ist das Speichern des Navigationszustands zugegebenermaßen nicht besonders wichtig. Dies ändert sich jedoch, sobald Sie einer App mehrere Seiten hinzufügen. Darüber hinaus gibt sie jeder Seite Gelegenheit zum Speichern und Wiederherstellen des eigenen Zustands. SuspensionManager serialisiert die Seitenzustandsdaten und schreibt sie in eine XML-Datei im lokalen Speicher der App.

Um die SuspensionManager-Klasse verwenden zu können, müssen Sie zunächst den Haupt-Frame der App registrieren. Wenn Sie damit fertig sind, kennt SuspensionManager die einzelnen Seiten in der App, und der Navigationszustand kann gespeichert und wiederhergestellt werden. Registrieren Sie den Frame direkt nach dessen Erstellung in der OnLaunched-Methode in App.xaml.cs/vb.

Hh986968.wedge(de-de,WIN.10).gifSo verwenden Sie die SuspensionManager-Klasse

  1. Doppelklicken Sie im Projektmappen-Explorer auf App.xaml.cs/vb, um diesen zu öffnen.
  2. Rufen Sie in der OnLaunched-Methode die SuspensionManager.RegisterFrame-Methode auf, um das Frame-Stammelement zu registrieren.
    
    HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame")
    
    

Fügen Sie den Code wie hier nach dem Erstellen des neuen Frame ein.


        If rootFrame Is Nothing Then
            ' Create a Frame to act as the navigation context and navigate to the first page
            rootFrame = New Frame()
            HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame")
        ...

Schritt 2: Speichern des App-Zustands

Ganz allgemein müssen in Ihrer App zwei Arten von Daten verwaltet werden: App-Daten und Sitzungsdaten. App-Daten bleiben sitzungsübergreifend erhalten und müssen dem Benutzer immer zur Verfügung stehen. In Ihrer App handelt es sich beim Text des TextBox-Elements nameInput um Benutzerdaten. Speichern Sie wichtige App-Daten schrittweise während des gesamten Lebenszyklus Ihrer App. Da die Ausführung von Code im Anhalteereignishandler nur maximal fünf Sekunden dauern darf, müssen Sie sicherstellen, dass die wichtigen App-Daten im beständigen Speicher gespeichert wurden, bevor die App angehalten wird.

Zur Unterstützung beim Verwalten von App-Daten stellt Windows ein Windows.Storage.ApplicationData-Objekt zur Verfügung. Dieses Objekt besitzt eine RoamingSettings-Eigenschaft, die einen ApplicationDataContainer zurückgibt. Mit diesem ApplicationDataContainer können Sie App-Daten speichern, die sitzungsübergreifend erhalten bleiben sollen. Speichern wir nun den Namen des Benutzers im ApplicationDataContainer für das Roaming, wenn der Benutzer ihn eingibt.

Hinweis  In diesem Lernprogramm wird die Verwendung von RoamingSettings gezeigt. Der Container für Sitzungsdaten der App für das Roaming erleichtert das Speichern von Daten, die für Benutzer auf mehreren Computern zugänglich sind. Im Grunde werden Ihre Daten im Hintergrund auf eine Cloud hochgeladen. Sie können auch den Container für lokale Sitzungsdaten der App verwenden (LocalSettings), sie sollten dies aber nur dann tun, wenn sie computerspezifische Informationen speichern möchten.

Beständige App-Daten sollten in der Anwendung möglichst häufig gespeichert werden. Hier behandeln Sie das TextBox.TextChanged-Ereignis und speichern den Benutzernamen, wenn der Benutzer ihn eingibt.

Hh986968.wedge(de-de,WIN.10).gifSo speichern Sie App-Daten

  1. Doppelklicken Sie im Projektmappen-Explorer auf MainPage.xaml, um diesen zu öffnen.
  2. Wählen Sie in der XAML (Extensible Application Markup Language)- oder Designansicht den TextBox vom Typ nameInput aus, den Sie MainPage.xaml hinzugefügt haben.
  3. Klicken Sie im Bereich Eigenschaften auf die Schaltfläche "Ereignisse" (Ereignisschaltfläche).
  4. Suchen Sie in der Ereignisliste das TextChanged-Ereignis. Geben Sie im Textfeld für das Ereignis "NameInput_TextChanged" als Namen der Funktion ein, die das TextChanged-Ereignis behandelt.
  5. Drücken Sie die EINGABETASTE. Die Ereignishandlermethode wird erstellt und im Code-Editor geöffnet, damit Sie den Code hinzufügen können, der bei Auftreten des Ereignisses ausgeführt werden soll.
  6. Fügen Sie diesen Code dem Ereignishandler auf der CodeBehind-Seite hinzu. Im Ereignishandler speichern Sie den nameInput-Text in roamingSettings.
    
    
            Dim roamingSettings = Windows.Storage.ApplicationData.Current.RoamingSettings
            roamingSettings.Values("userName") = nameInput.Text
    
    
    
  7. Drücken Sie F5, um die App zu erstellen und auszuführen. Ihr Name wird gespeichert, wenn Sie ihn in das Textfeld eingeben.

Sitzungsdaten sind temporäre Daten, die für die aktuelle Benutzersitzung in Ihrer App relevant sind. Eine Sitzung ist beendet, wenn der Benutzer die App mit der Geste zum Schließen oder mit STRG-F4 schließt, den Computer neu startet oder sich vom Computer abmeldet. In Ihrer App handelt es sich beim Text des TextBlock-Elements greetingOutput um Sitzungsdaten. Diese stellen Sie nur wieder her, falls Windows die App anhält und beendet. Sie müssen den Navigationszustand des App-Frames speichern, damit die App mit der Seite wiederhergestellt werden kann, auf der sie sich befand, und damit SuspensionManager weiß, für welche Seite der Zustand wiederhergestellt werden muss. Darüber hinaus müssen Sie auch den Zustand der Seite speichern. Hier speichern Sie den greetingOutput-Text. Sie verwenden die SuspensionManager-Klasse, um den Sitzungszustand im Application.Suspending-Ereignishandler zu speichern.

(Weitere Informationen zu den anderen Speichermethoden für den Zustand finden Sie unter Verwalten von App-Daten sowie unter Effizientes Verwenden des Zustands.)

Die Datei App.xaml.cs/vb enthält einen Handler für das Application.Suspending-Ereignis. Dieser Ereignishandler wird aufgerufen, wenn Windows im Begriff ist, Ihre App anzuhalten. Dies ist die perfekte Gelegenheit zum Speichern des App-Zustands für den Fall, dass die App beendet wird. Sie verwenden die SuspensionManager-Klasse, um das Speichern des Sitzungszustands zu vereinfachen. Damit wird der Navigationszustand der App gespeichert und das Speichern des Zustands der aktiven Seite ermöglicht.

Hh986968.wedge(de-de,WIN.10).gifSo speichern Sie den Sitzungszustand

  1. Doppelklicken Sie im Projektmappen-Explorer auf App.xaml.cs/vb, um diesen zu öffnen.
  2. Fügen Sie in App.xaml.cs/vb der OnSuspending-Methodensignatur das async-Schlüsselwort hinzu.

    Weitere Informationen zur asynchronen Programmierung finden Sie unter Schnellstart: Verwenden des await-Operators zum asynchronen Programmieren.

  3. Rufen Sie in der OnSuspending-Methode die SuspensionManager.SaveAsync-Methode auf.
    
    
            Await HelloWorld.Common.SuspensionManager.SaveAsync()
    
    
    

    Durch Aufrufen von SaveAsync wird der Navigationszustand des Frames gespeichert. Anschließend hat Ihre Page Gelegenheit zum Speichern ihres Inhalts.

    Hier ist die vollständige OnSuspending-Methode mit erfolgten Updates.

    
        ''' <summary>
        ''' Invoked when application execution is being suspended.  Application state is saved
        ''' without knowing whether the application will be terminated or resumed with the contents
        ''' of memory still intact.
        ''' </summary>
        ''' <param name="sender">The source of the suspend request.</param>
        ''' <param name="e">Details about the suspend request.</param>
    
        Private Async Sub OnSuspending(sender As Object, e As SuspendingEventArgs) Handles Me.Suspending
            Dim deferral = e.SuspendingOperation.GetDeferral()
            ' TODO: Save application state and stop any background activity
            Await HelloWorld.Common.SuspensionManager.SaveAsync()
            deferral.Complete()
        End Sub
    
    
  4. Doppelklicken Sie im Projektmappen-Explorer auf MainPage.xaml.cs/vb, um diesen zu öffnen.
  5. Fügen Sie in MainPage.xaml.cs/vb der navigationHelper_SaveState-Methode diesen Code zum Speichern des Seitenzustands hinzu.
    
    
                e.PageState("greetingOutputText") = greetingOutput.Text
    
    
    

    Die SuspensionManager-Klasse serialisiert und speichert das PageState-Wörterbuch in einer XML-Datei. In PageState gespeicherte Daten werden lediglich für diese Sitzung gespeichert. Hier speichern Sie den greetingOutput-Text.

    Hier sehen Sie den vollständigen Code der navigationHelper_SaveState-Methode.

    
    Private Sub NavigationHelper_SaveState(sender As Object, e As Common.SaveStateEventArgs)
        e.PageState("greetingOutputText") = greetingOutput.Text
    End Sub
    
    
  6. Klicken Sie auf Erstellen > Projektmappe erstellen, um sicherzustellen, dass die App ohne Fehler erstellt wird.

Mehr ist nicht erforderlich, um den Zustand der App zu speichern, bevor sie beendet wird. Nun müssen Sie sich damit beschäftigen, wie Sie den Zustand der App beim nächsten Start wiederherstellen.

Schritt 3: Wiederherstellen des App-Zustands

Wie wir bereits gesehen haben, enthält die Datei App.xaml.cs/vb Code zum Behandeln der App-Aktivierung. Eine App kann auf unterschiedlichste Weise aktiviert werden. Hier befassen wir uns mit der Launch-Aktivierung und der OnLaunched-Methode.

Eine App wird gestartet, wenn sie im nicht ausgeführten Zustand vom Benutzer aktiviert wird. Beim Start einer App zeigt Windows einen Begrüßungsbildschirm für die App an.

Sehen wir uns einmal den Code in App.xaml.cs/vb an, der die App-Aktivierung behandelt. Der Code definiert eine Überschreibung der OnLaunched-Methode. Der Code in dieser Methode wird nur ausgeführt, wenn es sich bei der Aktivierung um eine Launch-Aktivierung handelt. (Zur Behandlung anderer Aktivierungsarten können Sie auch andere Methoden überschreiben, darauf gehen wir hier allerdings nicht näher ein. Weitere Informationen finden Sie unter App-Lebenszyklus.)

Im Code wird zuerst ein Frame deklariert und versucht, ihm den Inhalt des aktuellen Fensters zuzuweisen.


Dim rootFrame As Frame = TryCast(Window.Current.Content, Frame)

Wenn das Fenster bereits einen Frame enthält, bedeutet dies, dass die App bereits initialisiert ist. Dann wird die Frame-Initialisierung übersprungen.

Wenn die App nicht initialisiert ist, erstellt der Code einen Frame, der als Host für die Seiten der App fungiert. Der Frame wird mit dem SuspensionManager registriert. Das ist der Code, den Sie in Schritt 1 hinzugefügt haben.

Im nächsten Schritt prüft der Code den vorherigen Ausführungszustand, um zu ermitteln, wie die App beim letzten Mal beendet wurde. Handelt es sich beim vorherigen Ausführungszustand um Terminated, bedeutet das, dass Windows die App bei der letzten Ausführung erfolgreich angehalten und anschließend beendet hat. In diesem Fall müssen Sie den Zustand der App wiederherstellen.


        ' Do not repeat app initialization when the Window already has content,
        ' just ensure that the window is active

        If rootFrame Is Nothing Then
            ' Create a Frame to act as the navigation context and navigate to the first page
            rootFrame = New Frame()
            HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame")

            If e.PreviousExecutionState = ApplicationExecutionState.Terminated Then
                ' TODO: Load state from previously suspended application
            End If
            ' Place the frame in the current Window
            Window.Current.Content = rootFrame
        End If

Dann überprüft der Code, ob der Frame Inhalt enthält. Wird die App bereits ausgeführt oder wurde der Navigationszustand wiederhergestellt, befindet sich bereits Inhalt im Frame. Andernfalls navigiert der Frame zur ersten Seite der App. In diesem Fall navigiert er zu MainPage.


        If rootFrame.Content Is Nothing Then
            ' When the navigation stack isn't restored navigate to the first page,
            ' configuring the new page by passing required information as a navigation
            ' parameter
            If Not rootFrame.Navigate(GetType(MainPage), e.Arguments) Then
                Throw New Exception("Failed to create initial page")
            End If
        End If

Schließlich aktiviert der Code das Fenster.


        ' Ensure the current window is active
        Window.Current.Activate()

Nachdem nun klar ist, was beim Start der App passiert, können wir uns der Wiederherstellung des App-Zustands widmen.

Hh986968.wedge(de-de,WIN.10).gifSo stellen Sie den Zustand der App wieder her

  1. Fügen Sie in App.xaml.cs/vb der OnLaunched-Methodensignatur das async-Schlüsselwort hinzu.
    
    Protected Overrides Async  Sub _
        OnLaunched(e As Windows.ApplicationModel.Activation.LaunchActivatedEventArgs))
    
    
  2. Wurde die App beendet, rufen Sie die SuspensionManager.RestoreAsync-Methode auf.

    Durch Aufrufen von RestoreAsync wird der Navigationszustand des Frames wiederhergestellt. Anschließend hat die Page Gelegenheit zum Wiederherstellen ihres Inhalts.

    
            If e.PreviousExecutionState = ApplicationExecutionState.Terminated Then
                ' TODO: Load state from previously suspended application
                Await HelloWorld.Common.SuspensionManager.RestoreAsync()
            End If
    
    
  3. Fügen Sie in MainPage.xaml.cs/vb der navigationHelper_LoadState-Methode Code zum Wiederherstellen des Seitenzustands hinzu.
    1. Prüfen Sie zunächst, ob das PageState-Wörterbuch vorhanden ist und den Schlüssel greetingOutputText aufweist. Wenn der Schlüssel vorhanden ist, stellen Sie damit den greetingOutput-Text wieder her.
      
      
              ' Restore values stored in session state.
              If e.PageState IsNot Nothing AndAlso e.PageState.ContainsKey("greetingOutputText") Then
                  greetingOutput.Text = e.PageState("greetingOutputText").ToString()
              End If
      
      
      
    2. Laden Sie dann den Benutzernamen. Da die Benutzernamendaten über mehrere Sitzungen hinweg erhalten bleiben sollen, speichern Sie sie im RoamingSettings-App-Datencontainer. Fügen wir nun Code hinzu, um zu prüfen, ob der Benutzername vorhanden ist, und (falls ja) ihn anzuzeigen.
      
              ' Restore values stored in app data.
              Dim roamingSettings =
                  Windows.Storage.ApplicationData.Current.RoamingSettings
      
              If roamingSettings.Values.ContainsKey("userName") Then
                  nameInput.Text = roamingSettings.Values("userName").ToString()
              End If
      
      
      

    Hier sehen Sie den vollständigen Code für die navigationHelper_LoadState-Methode.

    
        ''' <summary>
        ''' Populates the page with content passed during navigation.  Any saved state is also
        ''' provided when recreating a page from a prior session.
        ''' </summary>
        ''' <param name="sender">
        ''' The source of the event; typically <see cref="NavigationHelper"/>
        ''' </param>
        ''' <param name="e">Event data that provides both the navigation parameter passed to
        ''' <see cref="Frame.Navigate"/> when this page was initially requested and
        ''' a dictionary of state preserved by this page during an earlier
        ''' session.  The state will be null the first time a page is visited.</param>
        Private Sub NavigationHelper_LoadState(sender As Object, e As Common.LoadStateEventArgs)
            ' Restore values stored in session state.
            If e.PageState IsNot Nothing AndAlso e.PageState.ContainsKey("greetingOutputText") Then
                greetingOutput.Text = e.PageState("greetingOutputText").ToString()
            End If
    
            ' Restore values stored in app data.
            Dim roamingSettings =
                Windows.Storage.ApplicationData.Current.RoamingSettings
    
            If roamingSettings.Values.ContainsKey("userName") Then
                nameInput.Text = roamingSettings.Values("userName").ToString()
            End If
        End Sub
    
    

Jetzt können Sie die App erstellen und ausführen. Beachten Sie dabei, wie der Sitzungszustand gespeichert und wiederhergestellt wird. Bislang haben Sie Ihre App zum Testen im Debuggingmodus ausgeführt und mittels Debuggen > Debugging beenden in Visual Studio beendet. Dadurch führt die App jedoch eine normale Beendigung aus, und das Suspending-Ereignis tritt überhaupt nicht ein. Praktischerweise können Sie mit Visual Studio aber das Anhalten, Beenden und Reaktivieren einer App simulieren.

Hh986968.wedge(de-de,WIN.10).gifSo simulieren Sie das Anhalten, Beenden und Reaktivieren einer App in Visual Studio

  1. Drücken Sie F5, um die App im Debugmodus auszuführen.
  2. Geben Sie Ihren Namen in das Eingabefeld ein, und klicken Sie auf "Say "Hello"". Die Begrüßung wird angezeigt.
  3. Drücken Sie ALT+TAB, um zu Visual Studio zurückzukehren.
  4. Öffnen Sie auf der Symbolleiste Debugspeicherort das Dropdownmenü neben der Schaltfläche Anhalten.

    Die Symbolleiste Debugspeicherort wird während der Ausführung des Debuggers standardmäßig angezeigt. Sollte sie nicht angezeigt werden, klicken Sie auf Ansicht > Symbolleisten > Debugspeicherort, um sie einzublenden.

    Schaltfläche zum Anhalten und Herunterfahren

  5. Klicken Sie auf die Schaltfläche zum Anhalten und Herunterfahren.

    Visual Studio simuliert das Anhalten und Beenden Ihrer App, sodass das Suspending-Ereignis auftritt und der Code für die Zustandsverwaltung ausgeführt wird.

  6. Drücken Sie F5, um die App erneut auszuführen. Die App wird in ihrem vorherigen Zustand wiederhergestellt.
  7. Ändern Sie den Namen im Textfeld, und klicken Sie auf "Say "Hello"".
  8. Drücken Sie ALT+TAB, um zu Visual Studio zurückzukehren.
  9. Schließen Sie die App, indem Sie auf Debuggen > Debugging beenden klicken.
  10. Drücken Sie F5, um die App erneut auszuführen.

    Der Benutzername wird nun wiederhergestellt, da er bei der Eingabe gespeichert wurde. Die Begrüßung wird dagegen nicht wiederhergestellt, da das Suspending-Ereignis nicht aufgetreten ist und der Sitzungszustand somit nicht gespeichert wurde.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das zweite Lernprogramm vollständig durchgearbeitet! Sie haben gelernt, wie Sie App-Daten und Sitzungszustand in einer Windows-StoreApp speichern.

Siehe Code

Kommen Sie nicht voran, oder möchten Sie Ihre Arbeit überprüfen? Informationen finden Sie unter Teil 2: Vollständiger Code.

Nächste Schritte

Im nächsten Teil dieser Lernprogrammreihe lernen Sie, wie Sie mit den Entwicklungstools in Visual Studio eine etwas komplexere Benutzeroberfläche erstellen. Gehen Sie zu Teil 3: Navigation, Layout und Ansichten

 

 

Anzeigen:
© 2014 Microsoft