Längere Anzeige des Begrüßungsbildschirms

Artikel
07/05/2024

Verlängern Sie die Anzeige eines Begrüßungsbildschirms, indem Sie für die App einen erweiterten Begrüßungsbildschirm erstellen. Dieser erweiterte Bildschirm imitiert den Begrüßungsbildschirm, der beim Starten der App angezeigt wird, kann jedoch angepasst werden. Ganz gleich, ob Sie Informationen zum Laden in Echtzeit anzeigen oder Ihrer App zusätzliche Zeit geben möchten, um die erste Benutzeroberfläche vorzubereiten. Mit einem erweiterten Begrüßungsbildschirm können Sie die Startoberfläche definieren.

Hinweis

Der Ausdruck "erweiterter Begrüßungsbildschirm" in diesem Thema bezieht sich auf einen Begrüßungsbildschirm, der für einen längeren Zeitraum auf dem Bildschirm verbleibt. Es bedeutet keine Unterklasse, die von der SplashScreen-Klasse abgeleitet wird.

Wichtige APIs

Die folgenden APIs werden in diesem Thema verwendet:

Standardempfehlungen für den Begrüßungsbildschirm

Stellen Sie sicher, dass der erweiterte Begrüßungsbildschirm den standardmäßigen Begrüßungsbildschirm genau imitiert, indem Sie die folgenden Empfehlungen befolgen:

Die Seite für den erweiterten Begrüßungsbildschirm sollte ein Bild mit 620 x 300 Pixeln verwenden, das mit dem bild konsistent ist, das für den Begrüßungsbildschirm im App-Manifest (das Bild des Begrüßungsbildschirms Ihrer App) angegeben ist. In Microsoft Visual Studio werden die Einstellungen für den Begrüßungsbildschirm im Abschnitt "Begrüßungsbildschirm " der Registerkarte "Visuelle Objekte " in Ihrem App-Manifest (Datei "Package.appxmanifest") gespeichert.
Der erweiterte Begrüßungsbildschirm sollte eine Hintergrundfarbe verwenden, die mit der hintergrundfarbe konsistent ist, die für den Begrüßungsbildschirm im App-Manifest (der Hintergrund des Begrüßungsbildschirms Ihrer App) angegeben ist.
Ihr Code sollte die SplashScreen-Klasse verwenden, um das Bild des Begrüßungsbildschirms Ihrer App an den gleichen Bildschirmkoordinaten wie der standardmäßige Begrüßungsbildschirm zu positionieren.
Ihr Code sollte auf Ereignisse zur Fensteränderung reagieren (z. B. wenn der Bildschirm gedreht wird oder die App neben einer anderen App auf dem Bildschirm verschoben wird), indem sie die SplashScreen-Klasse verwenden, um Elemente auf dem erweiterten Begrüßungsbildschirm neu zu positionieren.

Führen Sie die folgenden Schritte aus, um einen erweiterten Begrüßungsbildschirm zu erstellen, der den standardmäßigen Begrüßungsbildschirm effektiv imitiert.

Hinzufügen eines leeren Seitenelements zu Ihrer vorhandenen App

In diesem Thema wird davon ausgegangen, dass Sie einem vorhandenen Universelle Windows-Plattform-App-Projekt (UWP) mit C#, Visual Basic oder C++ einen erweiterten Begrüßungsbildschirm hinzufügen möchten.

Öffnen Sie die App in Visual Studio.
Drücken oder öffnen Sie Project über die Menüleiste, und klicken Sie auf " Neues Element hinzufügen". Es wird ein Dialogfeld "Neues Element hinzufügen" angezeigt.
Fügen Sie in diesem Dialogfeld Ihrer App eine neue leere Seite hinzu. In diesem Thema wird die Seite für den erweiterten Begrüßungsbildschirm "ExtendedSplash" benannt.

Durch Hinzufügen eines Leeren Seitenelements werden zwei Dateien generiert, eine für Markup (ExtendedSplash.xaml) und eine für Code (ExtendedSplash.xaml.cs).

Grundlegendes XAML für einen erweiterten Begrüßungsbildschirm

Führen Sie die folgenden Schritte aus, um dem erweiterten Begrüßungsbildschirm ein Bild- und Statussteuerelement hinzuzufügen.

In der Datei "ExtendedSplash.xaml":

Ändern Sie die Background-Eigenschaft des Standardmäßigen Grid-Elements so, dass sie der Hintergrundfarbe entspricht, die Sie für den Begrüßungsbildschirm Ihrer App im App-Manifest festgelegt haben (im Abschnitt "Visuelle Objekte " der Datei "Package.appxmanifest"). Die Standardmäßige Farbe des Begrüßungsbildschirms ist hellgrau (Hexwert #464646). Beachten Sie, dass dieses Grid-Element standardmäßig bereitgestellt wird, wenn Sie eine neue leere Seite erstellen. Sie müssen kein Raster verwenden. Es ist nur eine bequeme Basis zum Erstellen eines erweiterten Begrüßungsbildschirms.
Fügen Sie dem Raster ein Canvas-Element hinzu. Sie verwenden diesen Canvas , um das Bild des erweiterten Begrüßungsbildschirms zu positionieren.
Fügen Sie der Canvas ein Image-Element hinzu. Verwenden Sie das gleiche Bild von 620 x 300 Pixeln für den erweiterten Begrüßungsbildschirm, den Sie für den standardmäßigen Begrüßungsbildschirm ausgewählt haben.
(Optional) Fügen Sie ein Statussteuerelement hinzu, um Benutzern anzuzeigen, dass Ihre App geladen wird. In diesem Thema wird anstelle eines bestimmten oder unbestimmten ProgressBar-Elements ein ProgressRing-Element hinzugefügt.

Im folgenden Beispiel wird ein Raster mit diesen Ergänzungen und Änderungen veranschaulicht.

    <Grid Background="#464646">
        <Canvas>
            <Image x:Name="extendedSplashImage" Source="Assets/SplashScreen.png"/>
            <ProgressRing Name="splashProgressRing" IsActive="True" Width="20" HorizontalAlignment="Center"></ProgressRing>
        </Canvas>
    </Grid>

Hinweis

In diesem Beispiel wird die Breite des ProgressRing auf 20 Pixel festgelegt. Sie können die Breite manuell auf einen Wert festlegen, der für Ihre App funktioniert. Das Steuerelement wird jedoch nicht mit einer Breite von weniger als 20 Pixeln gerendert.

Wesentlicher Code für eine erweiterte Begrüßungsbildschirmklasse

Der erweiterte Begrüßungsbildschirm muss reagieren, wenn sich die Fenstergröße (nur Windows) oder die Ausrichtung ändert. Die Position des verwendeten Bilds muss aktualisiert werden, damit der erweiterte Begrüßungsbildschirm unabhängig davon, wie sich das Fenster ändert, gut aussieht.

Verwenden Sie diese Schritte, um Methoden zum ordnungsgemäßen Anzeigen des erweiterten Begrüßungsbildschirms zu definieren.

Hinzufügen erforderlicher Namespaces

Sie müssen die folgenden Namespaces ExtendedSplash.xaml.cs hinzufügen, um auf die SplashScreen-Klasse, die Rect-Struktur und die Window.SizeChanged-Ereignisse zuzugreifen.
```
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.UI.Core;
```
Erstellen einer partiellen Klasse und Deklarieren von Klassenvariablen

Fügen Sie den folgenden Code in ExtendedSplash.xaml.cs ein, um eine partielle Klasse zum Darstellen eines erweiterten Begrüßungsbildschirms zu erstellen.
```
partial class ExtendedSplash : Page
{
    internal Rect splashImageRect; // Rect to store splash screen image coordinates.
    private SplashScreen splash; // Variable to hold the splash screen object.
    internal bool dismissed = false; // Variable to track splash screen dismissal status.
    internal Frame rootFrame;

   // Define methods and constructor
}
```
Diese Klassenvariablen werden von mehreren Methoden verwendet. Die splashImageRect Variable speichert die Koordinaten, in denen das System das Bild des Begrüßungsbildschirms für die App angezeigt hat. Die splash Variable speichert ein SplashScreen-Objekt , und die dismissed Variable verfolgt, ob der vom System angezeigte Begrüßungsbildschirm geschlossen wurde.

Definieren eines Konstruktors für Ihre Klasse, der das Bild korrekt positioniert

Der folgende Code definiert einen Konstruktor für die Klasse für den erweiterten Begrüßungsbildschirm, der auf Ereignisse zum Ändern der Fenstergröße lauscht, das Bild und (optional) Statussteuerelement auf dem erweiterten Begrüßungsbildschirm positioniert, einen Frame für die Navigation erstellt und eine asynchrone Methode zum Wiederherstellen eines gespeicherten Sitzungszustands aufruft.

public ExtendedSplash(SplashScreen splashscreen, bool loadState)
{
    InitializeComponent();

    // Listen for window resize events to reposition the extended splash screen image accordingly.
    // This ensures that the extended splash screen formats properly in response to window resizing.
    Window.Current.SizeChanged += new WindowSizeChangedEventHandler(ExtendedSplash_OnResize);

    splash = splashscreen;
    if (splash != null)
    {
        // Register an event handler to be executed when the splash screen has been dismissed.
        splash.Dismissed += new TypedEventHandler<SplashScreen, Object>(DismissedEventHandler);

        // Retrieve the window coordinates of the splash screen image.
        splashImageRect = splash.ImageLocation;
        PositionImage();

        // If applicable, include a method for positioning a progress control.
        PositionRing();
    }

    // Create a Frame to act as the navigation context
    rootFrame = new Frame();            
}

Registrieren Sie den Window.SizeChanged-Handler (ExtendedSplash_OnResize im Beispiel) im Klassenkonstruktor, damit das Bild in Ihrem erweiterten Begrüßungsbildschirm korrekt positioniert wird.

Definieren einer Klassenmethode zum Positionieren des Bilds im erweiterten Begrüßungsbildschirm

Dieser Code veranschaulicht, wie das Bild auf der Seite mit dem erweiterten Begrüßungsbildschirm mit der splashImageRect Klassenvariable positioniert wird.

void PositionImage()
{
    extendedSplashImage.SetValue(Canvas.LeftProperty, splashImageRect.X);
    extendedSplashImage.SetValue(Canvas.TopProperty, splashImageRect.Y);
    extendedSplashImage.Height = splashImageRect.Height;
    extendedSplashImage.Width = splashImageRect.Width;
}

(Optional) Definieren einer Klassenmethode zum Positionieren eines Statussteuerelements im erweiterten Begrüßungsbildschirm

Wenn Sie dem erweiterten Begrüßungsbildschirm ein ProgressRing-Element hinzufügen möchten, positionieren Sie es relativ zum Bild des Begrüßungsbildschirms. Fügen Sie den folgenden Code hinzu, um ExtendedSplash.xaml.cs, um das ProgressRing 32 Pixel unter dem Bild zu zentrieren.
```
void PositionRing()
{
    splashProgressRing.SetValue(Canvas.LeftProperty, splashImageRect.X + (splashImageRect.Width*0.5) - (splashProgressRing.Width*0.5));
    splashProgressRing.SetValue(Canvas.TopProperty, (splashImageRect.Y + splashImageRect.Height + splashImageRect.Height*0.1));
}
```

Definieren Sie innerhalb der Klasse einen Handler für das Dismissed-Ereignis.

Reagieren Sie in ExtendedSplash.xaml.cs, wenn das SplashScreen.Dismissed-Ereignis auftritt, indem Sie die dismissed Klassenvariable auf "true" festlegen. Wenn Ihre App Setupvorgänge hat, fügen Sie sie diesem Ereignishandler hinzu.

// Include code to be executed when the system has transitioned from the splash screen to the extended splash screen (application's first view).
void DismissedEventHandler(SplashScreen sender, object e)
{
    dismissed = true;

    // Complete app setup operations here...
}

Navigieren Sie nach Abschluss der App-Einrichtung vom erweiterten Begrüßungsbildschirm weg. Der folgende Code definiert eine Methode, die aufgerufen wird DismissExtendedSplash , die zur MainPage definierten Datei "MainPage.xaml" Ihrer App navigiert.

async void DismissExtendedSplash()
  {
     await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() =>            {
          rootFrame = new Frame();
          rootFrame.Content = new MainPage(); Window.Current.Content = rootFrame;
        });
  }

Definieren Sie innerhalb der Klasse einen Handler für Window.SizeChanged-Ereignisse.

Bereiten Sie den erweiterten Begrüßungsbildschirm vor, um seine Elemente neu zu positionieren, wenn ein Benutzer die Größe des Fensters ändert. Dieser Code reagiert, wenn ein Window.SizeChanged-Ereignis auftritt, indem die neuen Koordinaten erfasst und das Bild neu positioniert wird. Wenn Sie dem erweiterten Begrüßungsbildschirm ein Statussteuerelement hinzugefügt haben, positionieren Sie es auch innerhalb dieses Ereignishandlers.
```
void ExtendedSplash_OnResize(Object sender, WindowSizeChangedEventArgs e)
{
    // Safely update the extended splash screen image coordinates. This function will be executed when a user resizes the window.
    if (splash != null)
    {
        // Update the coordinates of the splash screen image.
        splashImageRect = splash.ImageLocation;
        PositionImage();

        // If applicable, include a method for positioning a progress control.
        // PositionRing();
    }
}
```
Hinweis

Bevor Sie versuchen, den Bildspeicherort abzurufen, stellen Sie sicher, dass die Klassenvariable (splash) ein gültiges SplashScreen-Objekt enthält, wie im Beispiel gezeigt.
(Optional) Hinzufügen einer Klassenmethode zum Wiederherstellen eines gespeicherten Sitzungszustands

Der Code, den Sie der OnLaunched-Methode in Schritt 4 hinzugefügt haben: Ändern des Startaktivierungshandlers bewirkt, dass ihre App beim Start einen erweiterten Begrüßungsbildschirm anzeigt. Um alle Methoden für den App-Start in der Klasse für den erweiterten Begrüßungsbildschirm zu konsolidieren, können Sie eine Methode zur ExtendedSplash.xaml.cs Datei hinzufügen, um den Zustand der App wiederherzustellen.
```
void RestoreState(bool loadState)
{
    if (loadState)
    {
         // code to load your app's state here
    }
}
```
Wenn Sie den Startaktivierungshandler in App.xaml.cs ändern, werden Sie auch auf "true" festgelegtloadstate, wenn der vorherige ApplicationExecutionState Ihrer App beendet wurde. Wenn ja, stellt die Methode die RestoreState App im vorherigen Zustand wieder her. Eine Übersicht über das Starten, Anhalten und Beenden von Apps finden Sie im App-Lebenszyklus.

Ändern des Startaktivierungshandlers

Wenn Ihre App gestartet wird, übergibt das System Informationen zum Begrüßungsbildschirm an den Ereignishandler für die Startaktivierung der App. Sie können diese Informationen verwenden, um das Bild auf der Seite mit dem erweiterten Begrüßungsbildschirm richtig zu positionieren. Sie können diese Begrüßungsbildschirminformationen aus den Aktivierungsereignisargumenten abrufen, die an den OnLaunched-Handler Ihrer App übergeben werden (siehe die args Variable im folgenden Code).

Wenn Sie den OnLaunched-Handler für Ihre App noch nicht außer Kraft gesetzt haben, lesen Sie den App-Lebenszyklus, um zu erfahren, wie Aktivierungsereignisse behandelt werden.

Fügen Sie in App.xaml.cs den folgenden Code hinzu, um einen erweiterten Begrüßungsbildschirm zu erstellen und anzuzeigen.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    if (args.PreviousExecutionState != ApplicationExecutionState.Running)
    {
        bool loadState = (args.PreviousExecutionState == ApplicationExecutionState.Terminated);
        ExtendedSplash extendedSplash = new ExtendedSplash(args.SplashScreen, loadState);
        Window.Current.Content = extendedSplash;
    }

    Window.Current.Activate();
}

Vollständiger Code

Der folgende Code unterscheidet sich geringfügig von den codeausschnitten, die in den vorherigen Schritten gezeigt wurden.

ExtendedSplash.xaml enthält eine DismissSplash Schaltfläche. Wenn auf diese Schaltfläche geklickt wird, DismissSplashButton_Clickruft ein Ereignishandler die DismissExtendedSplash Methode auf. Rufen Sie in Ihrer App auf DismissExtendedSplash , wenn das Laden von Ressourcen oder die Initialisierung der Benutzeroberfläche ihrer App abgeschlossen ist.
Diese App verwendet auch eine UWP-App-Projektvorlage, die die Frame-Navigation verwendet. Daher definiert der Startaktivierungshandler (OnLaunched) in App.xaml.cs einen rootFrame und verwendet ihn, um den Inhalt des App-Fensters festzulegen.

ExtendedSplash.xaml

Dieses Beispiel enthält eine DismissSplash Schaltfläche, da keine App-Ressourcen geladen werden können. Schließen Sie in Ihrer App den erweiterten Begrüßungsbildschirm automatisch, wenn die App das Laden von Ressourcen oder die Vorbereitung der ersten Benutzeroberfläche abgeschlossen hat.

<Page
    x:Class="SplashScreenExample.ExtendedSplash"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:SplashScreenExample"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="#464646">
        <Canvas>
            <Image x:Name="extendedSplashImage" Source="Assets/SplashScreen.png"/>
            <ProgressRing Name="splashProgressRing" IsActive="True" Width="20" HorizontalAlignment="Center"/>
        </Canvas>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Bottom">
            <Button x:Name="DismissSplash" Content="Dismiss extended splash screen" HorizontalAlignment="Center" Click="DismissSplashButton_Click" />
        </StackPanel>
    </Grid>
</Page>

ExtendedSplash.xaml.cs

Beachten Sie, dass die DismissExtendedSplash Methode vom Click-Ereignishandler für die DismissSplash Schaltfläche aufgerufen wird. In Ihrer App benötigen DismissSplash Sie keine Schaltfläche. Rufen Sie stattdessen auf DismissExtendedSplash , wenn die App das Laden von Ressourcen abgeschlossen hat und Sie zur Hauptseite navigieren möchten.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

using Windows.ApplicationModel.Activation;
using SplashScreenExample.Common;
using Windows.UI.Core;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234238

namespace SplashScreenExample
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    partial class ExtendedSplash : Page
    {
        internal Rect splashImageRect; // Rect to store splash screen image coordinates.
        private SplashScreen splash; // Variable to hold the splash screen object.
        internal bool dismissed = false; // Variable to track splash screen dismissal status.
        internal Frame rootFrame;

        public ExtendedSplash(SplashScreen splashscreen, bool loadState)
        {
            InitializeComponent();

            // Listen for window resize events to reposition the extended splash screen image accordingly.
            // This is important to ensure that the extended splash screen is formatted properly in response to snapping, unsnapping, rotation, etc...
            Window.Current.SizeChanged += new WindowSizeChangedEventHandler(ExtendedSplash_OnResize);

            splash = splashscreen;

            if (splash != null)
            {
                // Register an event handler to be executed when the splash screen has been dismissed.
                splash.Dismissed += new TypedEventHandler<SplashScreen, Object>(DismissedEventHandler);

                // Retrieve the window coordinates of the splash screen image.
                splashImageRect = splash.ImageLocation;
                PositionImage();

                // Optional: Add a progress ring to your splash screen to show users that content is loading
                PositionRing();
            }

            // Create a Frame to act as the navigation context
            rootFrame = new Frame();

            // Restore the saved session state if necessary
            RestoreState(loadState);
        }

        void RestoreState(bool loadState)
        {
            if (loadState)
            {
                // TODO: write code to load state
            }
        }

        // Position the extended splash screen image in the same location as the system splash screen image.
        void PositionImage()
        {
            extendedSplashImage.SetValue(Canvas.LeftProperty, splashImageRect.X);
            extendedSplashImage.SetValue(Canvas.TopProperty, splashImageRect.Y);
            extendedSplashImage.Height = splashImageRect.Height;
            extendedSplashImage.Width = splashImageRect.Width;

        }

        void PositionRing()
        {
            splashProgressRing.SetValue(Canvas.LeftProperty, splashImageRect.X + (splashImageRect.Width*0.5) - (splashProgressRing.Width*0.5));
            splashProgressRing.SetValue(Canvas.TopProperty, (splashImageRect.Y + splashImageRect.Height + splashImageRect.Height*0.1));
        }

        void ExtendedSplash_OnResize(Object sender, WindowSizeChangedEventArgs e)
        {
            // Safely update the extended splash screen image coordinates. This function will be fired in response to snapping, unsnapping, rotation, etc...
            if (splash != null)
            {
                // Update the coordinates of the splash screen image.
                splashImageRect = splash.ImageLocation;
                PositionImage();
                PositionRing();
            }
        }

        // Include code to be executed when the system has transitioned from the splash screen to the extended splash screen (application's first view).
        void DismissedEventHandler(SplashScreen sender, object e)
        {
            dismissed = true;

            // Complete app setup operations here...
        }

        void DismissExtendedSplash()
        {
            // Navigate to mainpage
            rootFrame.Navigate(typeof(MainPage));
            // Place the frame in the current Window
            Window.Current.Content = rootFrame;
        }

        void DismissSplashButton_Click(object sender, RoutedEventArgs e)
        {
            DismissExtendedSplash();
        }
    }
}

App.xaml.cs

Dieses Projekt wurde mit der Xaml-Projektvorlage (Blank App) der UWP-App in Visual Studio erstellt. Sowohl die Ereignishandler als auch die OnNavigationFailed OnSuspending Ereignishandler werden automatisch generiert und müssen nicht geändert werden, um einen erweiterten Begrüßungsbildschirm zu implementieren. In diesem Thema wird nur geändert OnLaunched.

Wenn Sie keine Projektvorlage für Ihre App verwendet haben, lesen Sie Schritt 4: Ändern des Startaktivierungshandlers für ein Beispiel für eine geänderteOnLaunched, die keine Framenavigation verwendet.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Application template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234227

namespace SplashScreenExample
{
    /// <summary>
    /// Provides application-specific behavior to supplement the default Application class.
    /// </summary>
    sealed partial class App : Application
    {
        /// <summary>
        /// Initializes the singleton application object.  This is the first line of authored code
        /// executed, and as such is the logical equivalent of main() or WinMain().
        /// </summary>
        public App()
        {
            Microsoft.ApplicationInsights.WindowsAppInitializer.InitializeAsync(
            Microsoft.ApplicationInsights.WindowsCollectors.Metadata |
            Microsoft.ApplicationInsights.WindowsCollectors.Session);
            this.InitializeComponent();
            this.Suspending += OnSuspending;
        }

        /// <summary>
        /// Invoked when the application is launched normally by the end user.  Other entry points
        /// will be used such as when the application is launched to open a specific file.
        /// </summary>
        /// <param name="e">Details about the launch request and process.</param>
        protected override void OnLaunched(LaunchActivatedEventArgs e)
        {
#if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                this.DebugSettings.EnableFrameRateCounter = true;
            }
#endif

            Frame rootFrame = Window.Current.Content as Frame;

            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();
                // Set the default language
                rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

                rootFrame.NavigationFailed += OnNavigationFailed;

                //  Display an extended splash screen if app was not previously running.
                if (e.PreviousExecutionState != ApplicationExecutionState.Running)
                {
                    bool loadState = (e.PreviousExecutionState == ApplicationExecutionState.Terminated);
                    ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen, loadState);
                    rootFrame.Content = extendedSplash;
                    Window.Current.Content = rootFrame;
                }
            }

            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                rootFrame.Navigate(typeof(MainPage), e.Arguments);
            }
            // Ensure the current window is active
            Window.Current.Activate();
        }

        /// <summary>
        /// Invoked when Navigation to a certain page fails
        /// </summary>
        /// <param name="sender">The Frame which failed navigation</param>
        /// <param name="e">Details about the navigation failure</param>
        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
        {
            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
        }

        /// <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 void OnSuspending(object sender, SuspendingEventArgs e)
        {
            var deferral = e.SuspendingOperation.GetDeferral();
            // TODO: Save application state and stop any background activity
            deferral.Complete();
        }
    }
}

App-Lebenszyklus

Referenz

Freigeben über

Längere Anzeige des Begrüßungsbildschirms

Wichtige APIs

Standardempfehlungen für den Begrüßungsbildschirm

Hinzufügen eines leeren Seitenelements zu Ihrer vorhandenen App

Grundlegendes XAML für einen erweiterten Begrüßungsbildschirm

Wesentlicher Code für eine erweiterte Begrüßungsbildschirmklasse

Ändern des Startaktivierungshandlers

Vollständiger Code

ExtendedSplash.xaml

ExtendedSplash.xaml.cs

App.xaml.cs

Feedback

Zusätzliche Ressourcen

Freigeben über

Längere Anzeige des Begrüßungsbildschirms

Wichtige APIs

Standardempfehlungen für den Begrüßungsbildschirm

Hinzufügen eines leeren Seitenelements zu Ihrer vorhandenen App

Grundlegendes XAML für einen erweiterten Begrüßungsbildschirm

Wesentlicher Code für eine erweiterte Begrüßungsbildschirmklasse

Ändern des Startaktivierungshandlers

Vollständiger Code

ExtendedSplash.xaml

ExtendedSplash.xaml.cs

App.xaml.cs

Zugehörige Themen

Feedback

Zusätzliche Ressourcen