So wird's gemacht: Erweitern des Begrüßungsbildschirms
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Language: HTML | XAML

So wird’s gemacht: Erweitern des Begrüßungsbildschirms (XAML)

[ Dieser Artikel richtet sich an Windows 8.x- und Windows Phone 8.x-Entwickler, die Windows-Runtime-Apps schreiben. Wenn Sie für Windows 10 entwickeln, finden Sie weitere Informationen unter neueste Dokumentation]

Verlängern Sie die Anzeige eines Begrüßungsbildschirms, indem Sie für die App einen erweiterten Begrüßungsbildschirm erstellen. Mit diesem erweiterten Bildschirm wird der beim Starten der App angezeigte Begrüßungsbildschirm imitiert. Er kann aber angepasst werden. Mit einem erweiterten Begrüßungsbildschirm können Sie das Startverhalten unabhängig davon definieren, ob Sie Echtzeitinformationen zum Ladevorgang anzeigen oder der App lediglich zusätzliche Zeit zum Vorbereiten der UI-Anfangselemente geben möchten. Einen erweiterten Begrüßungsbildschirm in einer vollständigen App finden Sie unter Begrüßungsbildschirmbeispiel.

Sie verwenden JavaScript und HTML? Informationen hierzu finden Sie unter How to extend the splash screen (Windows Store apps using Javascript and HTML).

Hinweis  Die Bezeichnung "erweiterter Begrüßungsbildschirm" in diesem Thema bezieht sich auf einen Begrüßungsbildschirm, der für längere Zeit auf dem Bildschirm angezeigt wird. Sie bezieht sich nicht auf eine Unterklasse, die von der SplashScreen-Klasse abgeleitet ist.
 

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

  • Sie sollten für die Seite mit dem erweiterten Begrüßungsbildschirm ein Bild mit 620 x 300 Pixeln verwenden. Es sollte zudem mit dem Bild übereinstimmen, das im App-Manifest für den Begrüßungsbildschirm angegeben ist (dem Bild des App-Begrüßungsbildschirms). In Microsoft Visual Studio 2013 werden die Einstellungen für den Begrüßungsbildschirm im App-Manifest (Datei Package.appxmanifest) auf der Registerkarte Visuelle Anlagen unter Begrüßungsbildschirm gespeichert.
  • Sie sollten für den erweiterten Begrüßungsbildschirm eine Hintergrundfarbe verwenden, die mit der in Ihrem App-Manifest für Ihren Begrüßungsbildschirm angegebenen Hintergrundfarbe konsistent ist (dem Hintergrund des Begrüßungsbildschirms Ihrer App).
  • Sie müssen im Code die SplashScreen-Klasse verwenden, um das Bild des App-Begrüßungsbildschirms an den gleichen Koordinaten zu positionieren, an denen der standardmäßige Begrüßungsbildschirms positioniert wird.
  • Der Code sollte mithilfe der SplashScreen-Klasse auf Ereignisse zur Änderung der Fenstergröße (beispielsweise beim Drehen des Bildschirms oder Verschieben der App neben eine andere App auf dem Bildschirm) reagieren, um die Elemente auf dem erweiterten Begrüßungsbildschirm neu anzuordnen.

Erstellen Sie mit den folgenden Schritten einen erweiterten Begrüßungsbildschirm, der den standardmäßigen Begrüßungsbildschirm wirkungsvoll imitiert.

Voraussetzungen

Anweisungen

Schritt 1: Hinzufügen des Elements Leere Seite zur vorhandenen App

  • Öffnen Sie die App in Visual Studio 2013.
  • Drücken Sie , oder klicken Sie auf der Menüleiste auf Projekt und dann auf Neues Element hinzufügen. Das Dialogfeld Neues Element hinzufügen wird angezeigt.
  • Fügen Sie der App in diesem Dialogfeld ein neues Element Leere Seite hinzu. In diesem Thema erhält die Seite mit dem erweiterten Begrüßungsbildschirm den Namen "ExtendedSplash".

Beim Hinzufügen des Elements Leere Seite werden zwei Dateien erstellt: eine für Markup (ExtendedSplash.xaml) und eine für Code (ExtendedSplash.xaml.cs).

Schritt 2: Grundlegender XAML-Code für einen erweiterten Begrüßungsbildschirm

Führen Sie diese Schritte aus, um dem erweiterten Begrüßungsbildschirm ein Bild und ein Statussteuerelement hinzuzufügen. Weitere Anleitungen zum Entwerfen eines erweiterten Begrüßungsbildschirms finden Sie unter Richtlinien und Prüfliste für Begrüßungsbildschirme.

Gehen Sie in der Datei ExtendedSplash.xaml wie folgt vor:

  • Ändern Sie die Background-Eigenschaft des Grid-Standardelements, um sie an die Hintergrundfarbe anzupassen, die Sie im App-Manifest für den Begrüßungsbildschirm der App festgelegt haben (im Abschnitt Visuelle Anlagen der Datei Package.appxmanifest). Die Standardfarbe des Begrüßungsbildschirms ist Hellgrau (Hexadezimalwert #464646). Beachten Sie, dass dieses Grid-Element standardmäßig bereitgestellt wird, wenn Sie eine neue Leere Seite erstellen. Sie müssen nicht zwingend ein Grid-Element verwenden. Es handelt sich dabei lediglich um eine gut geeignete Basis zum Erstellen eines erweiterten Begrüßungsbildschirms.
  • Fügen Sie dem Grid-Element ein Canvas-Element hinzu. Sie verwenden dieses Canvas-Element zum Positionieren des Bilds für den erweiterten Begrüßungsbildschirm.
  • Fügen Sie dem Canvas-Element ein Image-Element hinzu. Verwenden Sie für den erweiterten Begrüßungsbildschirm das gleiche Bild mit einer Größe von 600 x 320 Pixel, das Sie für den standardmäßigen Begrüßungsbildschirm gewählt haben.
  • (Optional) Fügen Sie ein Statussteuerelement hinzu, um Benutzern anzuzeigen, dass die App geladen wird. In diesem Thema wird anstelle eines bestimmten oder unbestimmten ProgressBar-Elements ein ProgressRing-Element hinzugefügt. Informationen zum Hinzufügen eines ProgressBar-Elements zur App finden Sie unter Hinzufügen von Statussteuerelementen. Eine Übersicht über verfügbare Steuerelemente und Empfehlungen zur Nutzung finden Sie unter Guidelines for progress controls.

Fügen Sie den folgenden Code hinzu, um Canvas- und Image-Elemente sowie ein ProgressRing-Steuerelement in ExtendedSplash.xaml hinzuzufügen:


    <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  Mit diesem Code wird die Breite des ProgressRing-Elements auf 20 Pixel festgelegt. Sie können die Breite manuell auf einen Wert festlegen, der für Ihre App geeignet ist. Das Steuerelement wird jedoch nicht für Breiten unterhalb von 20 Pixel gerendert.
 

Schritt 3: Grundlegender Code für die Klasse eines erweiterten Begrüßungsbildschirms

Der erweiterte Begrüßungsbildschirm muss entsprechend 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 von der Änderung des Fensters gut aussieht.

Führen Sie die folgenden Schritte aus, um Methoden zu definieren, damit der erweiterte Begrüßungsbildschirm richtig dargestellt wird.

  1. Hinzufügen von erforderlichen Namespaces

    Sie müssen der Datei ExtendedSplash.xaml.cs die folgenden Namespaces hinzufügen, um auf die SplashScreen-Klasse, Window.SizeChanged-Ereignisse (nur Windows) und die SuspensionManager-Klasse zugreifen zu können (verfügbar im Ordner Allgemein einer Projektvorlage vom Typ Leere App, Raster-App oder Split App).

    
    using Windows.ApplicationModel.Activation;
    using Windows.UI.Core;
    using SplashScreenExample.Common;
    
    
    Hinweis  Ersetzen Sie "SplashScreenExample" in der Zeile using SplashScreenExample.Common; durch den Namen Ihres Windows-Runtime-App-Projekts.
     
    Hinweis  Mit dem Code in diesem Thema wird mithilfe der Klasse des erweiterten Begrüßungsbildschirms für die App ein vorheriger Sitzungszustand wiederhergestellt. Damit werden die Aufgaben zum Starten der App in ExtendedSplash.xaml.cs zusammengefasst. Sie können den Sitzungszustand stattdessen auch direkt über den OnLaunched-Handler in App.xaml.cs wiederherstellen, wenn Sie dies bevorzugen.
     
  2. Erstellen Sie eine partielle Klasse, und deklarieren Sie Klassenvariablen

    Fügen Sie den folgenden Code in die Datei 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 verschiedenen Methoden verwendet. Die splashImageRect-Variable speichert die Koordinaten der Position, an der das System das Begrüßungsbildschirmbild 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.

  3. Definieren eines Konstruktors für die Klasse, der das Bild richtig positioniert

    Mit dem folgenden Code wird ein Konstruktor für die Klasse des erweiterten Begrüßungsbildschirms definiert, der eine Überprüfung auf Ereignisse zum Ändern der Fenstergröße durchführt, das Bild und (optional) das Statussteuerelement auf dem erweiterten Begrüßungsbildschirm positioniert, einen Rahmen 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();
                
        // Restore the saved session state if necessary
        RestoreStateAsync(loadState);
    }
    
    

    Registrieren Sie den Window.SizeChanged-Handler (in diesem Beispiel ExtendedSplash_OnResize) im Klassenkonstruktor, damit das Bild von der App auf dem erweiterten Begrüßungsbildschirm richtig positioniert wird.

  4. Definieren Sie eine Klassenmethode, um das Bild auf dem erweiterten Begrüßungsbildschirm zu positionieren

    Mit diesem Code wird veranschaulicht, wie das Bild mithilfe der splashImageRect-Klassenvariablen auf dem erweiterten Begrüßungsbildschirm positioniert wird.

    
    void PositionImage()
    {
        extendedSplashImage.SetValue(Canvas.LeftProperty, splashImageRect.X);
        extendedSplashImage.SetValue(Canvas.TopProperty, splashImageRect.Y);
        extendedSplashImage.Height = splashImageRect.Height;
        extendedSplashImage.Width = splashImageRect.Width;
    }
    
    
  5. (Optional) Definieren einer Klassenmethode, um ein Statussteuerelement auf dem erweiterten Begrüßungsbildschirm zu positionieren

    Wenn Sie sich für das Hinzufügen eines ProgressRing-Elements zum erweiterten Begrüßungsbildschirm entscheiden, sollten Sie es relativ zum Bild des Begrüßungsbildschirms positionieren. Fügen Sie der Datei ExtendedSplash.xaml.cs den folgenden Code hinzu, um das ProgressRing-Element 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));
    }
    
    
  6. Definieren Sie innerhalb der Klasse einen Handler für das Dismissed-Ereignis.

    Reagieren Sie in ExtendedSplash.xaml.cs beim Auftreten des SplashScreen.Dismissed-Ereignisses, indem Sie die dismissed-Klassenvariable auf "true" festlegen. Falls Ihre App über Setupvorgänge verfügt, 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...
    }
    
    

    Führen Sie nach Abschluss des App-Setups eine Navigation weg vom erweiterten Begrüßungsbildschirm durch. Mit dem folgenden Code wird eine Methode mit dem Namen DismissExtendedSplash definiert. Diese dient der Navigation zur MainPage, die in der Datei MainPage.xaml der App definiert ist.

    
    void DismissExtendedSplash()
    {
        // Navigate to mainpage
        rootFrame.Navigate(typeof(MainPage));
        // Place the frame in the current Window
        Window.Current.Content = rootFrame;
    }
    
    
  7. Definieren Sie innerhalb der Klasse einen Handler für Windows.SizeChanged-Ereignisse.

    Bereiten Sie den erweiterten Begrüßungsbildschirm so vor, dass die Elemente neu angeordnet werden, wenn Benutzer die Größe des Fensters ändern. Mit diesem Code wird beim Auftreten eines Window.SizeChanged-Ereignisses reagiert, indem die neuen Koordinaten erfasst werden und das Bild neu positioniert wird. Wenn Sie dem erweiterten Begrüßungsbildschirm ein Statussteuerelement hinzugefügt haben, sollten Sie es in diesem Ereignishandler ebenfalls neu positionieren.

    
    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, die Bildposition abzurufen, müssen Sie wie im Beispiel gezeigt sicherstellen, dass die Klassenvariable (splash) ein gültiges SplashScreen-Objekt enthält.
     
  8. Hinzufügen einer Klassenmethode zum Wiederherstellen eines gespeicherten Sitzungszustands

    Den Code, den Sie der OnLaunched-Methode unter "Schritt 4: Ändern Sie den Startaktivierungshandler" hinzugefügt haben, führt dazu, dass die App beim Starten einen erweiterten Begrüßungsbildschirm anzeigt. Fügen Sie die folgende asynchrone Methode der Datei ExtendedSplash.xaml.cs hinzu, um alle Methoden für das Starten der App unter der Klasse für den erweiterten Begrüßungsbildschirm zusammenzufassen.

    
    async void RestoreStateAsync(bool loadState)
    {
        if (loadState)
            await SuspensionManager.RestoreAsync();
    }
    
    

    Beim Ändern des Startaktivierungshandlers in App.xaml.cs sollten Sie zusätzlich loadstate auf "true" festlegen, wenn das vorherige ApplicationExecutionState-Element der App Terminated lautete. Ist dies der Fall, wird von der RestoreStateAsync-Methode SuspensionManager aufgerufen, um den vorherigen Zustand der App wiederherzustellen. Eine Übersicht über das Starten, Anhalten und Beenden einer App finden Sie unter App-Lebenszyklus.

Schritt 4: Ändern Sie den Startaktivierungshandler

Beim Starten Ihrer App übergibt das System Begrüßungsbildschirminformationen an den Handler für das Startaktivierungsereignis. 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 Argumenten des Aktivierungsereignisses abrufen, die an den OnLaunched-Handler der App übergeben werden (siehe args-Variable im folgenden Code).

Wenn Sie den OnLaunched-Handler für Ihre App noch nicht außer Kraft gesetzt haben, finden Sie unter So wird's gemacht: Aktivieren einer App Informationen zum Behandeln von Aktivierungsereignissen.

Fügen Sie in der Datei App.xaml.cs den folgenden Code zum Erstellen und Anzeigen eines erweiterten Begrüßungsbildschirms hinzu.


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


Schritt 5: Vollständiger Code

Hinweis  Der folgende Code unterscheidet sich leicht von den Codeausschnitten der vorherigen Schritte.
  • ExtendedSplash.xaml enthält eine DismissSplash-Schaltfläche. Beim Klicken auf diese Schaltfläche wird mit dem DismissSplashButton_Click-Ereignishandler die DismissExtendedSplash-Methode aufgerufen. Rufen Sie in der App DismissExtendedSplash auf, wenn das Laden von Ressourcen oder Initialisieren der UI in der App abgeschlossen ist.
  • Für diese App wird auch eine Windows-Runtime-App-Projektvorlage verwendet, bei der die Frame-Navigation zum Einsatz kommt. Der Startaktivierungshandler (OnLaunched) definiert in App.xaml.cs dann ein rootFrame-Element und verwendet es zum Festlegen des Inhalts für das App-Fenster.
 

ExtendedSplash.xaml: Dieses Beispiel enthält eine DismissSplash-Schaltfläche, da keine App-Ressourcen geladen werden müssen. Blenden Sie den erweiterten Begrüßungsbildschirm in der App automatisch aus, wenn das Laden von Ressourcen oder Vorbereiten der UI-Anfangselemente in der App abgeschlossen ist.


<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 der App benötigen Sie keine DismissSplash-Schaltfläche. Rufen Sie stattdessen DismissExtendedSplash auf, wenn das Laden der Ressourcen in der App abgeschlossen ist und Sie die Navigation zur Hauptseite durchführen 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 http://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
            RestoreStateAsync(loadState);
        }

        async void RestoreStateAsync(bool loadState)
        {
            if (loadState)
                await SuspensionManager.RestoreAsync();
        }

        // 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 mithilfe der Windows-Runtime-App-Projektvorlage Leere App (XAML) in Visual Studio 2013 erstellt. Die Ereignishandler OnNavigationFailed und OnSuspending werden automatisch erstellt und müssen nicht geändert werden, um einen erweiterten Begrüßungsbildschirm zu implementieren. In diesem Thema wird nur OnLaunched geändert.

Falls Sie für Ihre App keine Projektvorlage verwendet haben, finden Sie unter "Schritt 4: Ändern Sie den Startaktivierungshandler ein Beispiel für einen geänderten OnLaunched-Handler ohne Frame-Navigation.


using SplashScreenExample.Common;
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 http://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()
        {
            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>
        async private void OnSuspending(object sender, SuspendingEventArgs e)
        {
            var deferral = e.SuspendingOperation.GetDeferral();
            await SuspensionManager.SaveAsync();
            deferral.Complete();
        }
    }
}


Anmerkungen

Tipp  Wenn Sie diesen Anweisungen folgen und beim Übergang zum erweiterten Begrüßungsbildschirm ein Flimmern bemerken, finden Sie Hilfe im Abschnitt Problembehandlung unter Richtlinien und Prüfliste für Begrüßungsbildschirme.
 

Verwandte Themen

Richtlinien und Prüfliste für Begrüßungsbildschirme
So wird's gemacht: Aktivieren einer App
App-Lebenszyklus (Übersicht)
Begrüßungsbildschirmbeispiel
How to extend the splash screen (Windows Store apps using Javascript and HTML)
Referenz
Windows.ApplicationModel.Activation namespace
Windows.ApplicationModel.Activation.SplashScreen class
Windows.ApplicationModel.Activation.SplashScreen.ImageLocation property
Windows.ApplicationModel.Core.CoreApplicationView.Activated event

 

 

Anzeigen:
© 2017 Microsoft