Riwayat navigasi dan navigasi mundur - Windows apps

Artikel
07/13/2023

API Penting: Peristiwa BackRequested, kelas SystemNavigationManager, OnNavigatedTo

Aplikasi Windows menyediakan sistem navigasi belakang yang konsisten untuk melintas riwayat navigasi pengguna dalam aplikasi dan, tergantung pada perangkat, dari aplikasi ke aplikasi.

Untuk menerapkan navigasi mundur di aplikasi Anda, letakkan tombol kembali di sudut kiri atas UI aplikasi Anda. Pengguna mengharapkan tombol kembali untuk menavigasi ke lokasi sebelumnya dalam riwayat navigasi aplikasi. Perhatikan bahwa terserah Anda untuk memutuskan tindakan navigasi mana yang akan ditambahkan ke riwayat navigasi dan cara merespons penekanan tombol kembali.

Untuk sebagian besar aplikasi yang memiliki beberapa halaman, kami sarankan Anda menggunakan kontrol NavigationView untuk menyediakan kerangka kerja navigasi untuk aplikasi Anda. Ini beradaptasi dengan berbagai ukuran layar dan mendukung gaya navigasi atas dan kiri . Jika aplikasi Anda menggunakan NavigationView kontrol, maka Anda dapat menggunakan tombol kembali bawaan NavigationView.

Catatan

Panduan dan contoh dalam artikel ini harus digunakan saat Anda menerapkan navigasi tanpa menggunakan NavigationView kontrol. Jika Anda menggunakan NavigationView, informasi ini memberikan pengetahuan latar belakang yang berguna, tetapi Anda harus menggunakan panduan dan contoh tertentu di artikel NavigationView

Tombol Kembali

Untuk membuat tombol kembali, gunakan kontrol Tombol dengan NavigationBackButtonNormalStyle gaya, dan letakkan tombol di sudut kiri atas UI aplikasi Anda (untuk detailnya, lihat contoh kode XAML di bawah).

<Page>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <Button x:Name="BackButton"
                Style="{StaticResource NavigationBackButtonNormalStyle}"
                IsEnabled="{x:Bind Frame.CanGoBack, Mode=OneWay}" 
                ToolTipService.ToolTip="Back"/>

    </Grid>
</Page>

Jika aplikasi Anda memiliki CommandBar teratas, kontrol Tombol yang tingginya 44epx tidak akan selaras dengan AppBarButtons 48epx dengan sangat baik. Namun, untuk menghindari ketidakkonsistensian, sejajarkan bagian atas kontrol Tombol di dalam batas 48epx.

<Page>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        
        <CommandBar>
            <CommandBar.Content>
                <Button x:Name="BackButton"
                        Style="{StaticResource NavigationBackButtonNormalStyle}"
                        IsEnabled="{x:Bind Frame.CanGoBack, Mode=OneWay}" 
                        ToolTipService.ToolTip="Back" 
                        VerticalAlignment="Top"/>
            </CommandBar.Content>
        
            <AppBarButton Icon="Delete" Label="Delete"/>
            <AppBarButton Icon="Save" Label="Save"/>
        </CommandBar>
    </Grid>
</Page>

Untuk meminimalkan elemen UI yang bergerak di sekitar aplikasi Anda, tampilkan tombol kembali yang dinonaktifkan saat tidak ada apa pun di tumpukan belakang (IsEnabled="{x:Bind Frame.CanGoBack, Mode=OneWay}"). Namun, jika Anda mengharapkan aplikasi Anda tidak akan pernah memiliki tumpukan belakang, Anda tidak perlu menampilkan tombol kembali sama sekali.

Optimalkan untuk perangkat dan input yang berbeda

Panduan desain navigasi mundur ini berlaku untuk semua perangkat, tetapi pengguna Anda akan mendapat manfaat jika Anda mengoptimalkan faktor bentuk dan metode input yang berbeda.

Untuk mengoptimalkan UI Anda:

Desktop/Hub: Gambar tombol kembali dalam aplikasi di sudut kiri atas UI aplikasi Anda.
Mode Tablet: Tombol kembali perangkat keras atau perangkat lunak mungkin ada di tablet, tetapi sebaiknya gambar tombol kembali dalam aplikasi untuk kejelasan.
Xbox/TV: Jangan gambar tombol kembali; itu akan menambahkan kekacauan UI yang tidak perlu. Sebagai gantinya, mengandalkan tombol game pad B untuk menavigasi mundur.

Jika aplikasi Anda akan berjalan di Xbox, buat pemicu visual kustom untuk Xbox untuk mengaktifkan visibilitas tombol. Jika Anda menggunakan kontrol NavigationView , kontrol tersebut akan secara otomatis mengalihkan visibilitas tombol kembali saat aplikasi Anda berjalan di Xbox.

Sebaiknya tangani peristiwa berikut (selain tombol kembali Klik) untuk mendukung input yang paling umum untuk navigasi belakang.

Aktivitas	Input
CoreDispatcher.AcceleratorKeyActivated	Alt+Panah kiri, VirtualKey.GoBack
SystemNavigationManager.BackRequested	Windows + Backspace, Tombol Gamepad B, Tombol kembali Mode Tablet, Tombol kembali perangkat keras
CoreWindow.PointerPressed	VirtualKey.XButton1 (Seperti tombol kembali yang ditemukan pada beberapa tikus.)

Contoh kode

Bagian ini menunjukkan cara menangani kembali navigasi menggunakan berbagai input.

Minimal, Anda perlu menangani peristiwa tombol Click kembali dan menyediakan kode untuk melakukan navigasi belakang. Anda juga harus menonaktifkan tombol kembali saat tumpukan belakang kosong.

Contoh kode ini menunjukkan cara menerapkan perilaku navigasi mundur dengan tombol kembali. Kode merespons peristiwa Klik Tombol untuk menavigasi. Tombol kembali diaktifkan atau dinonaktifkan dalam metode OnNavigatedTo , yang dipanggil saat menavigasi ke halaman baru.

Kode ditampilkan untuk MainPage, tetapi Anda menambahkan kode ini ke setiap halaman yang mendukung kembali navigasi. Untuk menghindari duplikasi, Anda dapat meletakkan kode terkait navigasi di App kelas di App.xaml.* halaman code-behind.

<!-- MainPage.xaml -->
<Page x:Class="AppName.MainPage">
...
        <Button x:Name="BackButton" Click="BackButton_Click"
                Style="{StaticResource NavigationBackButtonNormalStyle}"
                IsEnabled="{x:Bind Frame.CanGoBack, Mode=OneWay}" 
                ToolTipService.ToolTip="Back"/>
...
<Page/>

Kode di belakang:

// MainPage.xaml.cs
private void BackButton_Click(object sender, RoutedEventArgs e)
{
    App.TryGoBack();
}

// App.xaml.cs
//
// Add this method to the App class.
public static bool TryGoBack()
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoBack)
    {
        rootFrame.GoBack();
        return true;
    }
    return false;
}

// MainPage.h
namespace winrt::AppName::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
        MainPage();
 
        void MainPage::BackButton_Click(IInspectable const&, RoutedEventArgs const&)
        {
            App::TryGoBack();
        }
    };
}

// App.h
#include "winrt/Windows.UI.Core.h"
#include "winrt/Windows.System.h"
#include "winrt/Windows.UI.Input.h"
#include "winrt/Windows.UI.Xaml.Input.h"
 
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::UI::Core;
using namespace Windows::UI::Input;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;

struct App : AppT<App>
{
    App();

    // ...

    // Perform back navigation if possible.
    static bool TryGoBack()
    {
        Frame rootFrame{ nullptr };
        auto content = Window::Current().Content();
        if (content)
        {
            rootFrame = content.try_as<Frame>();
            if (rootFrame.CanGoBack())
            {
                rootFrame.GoBack();
                return true;
            }
        }
        return false;
    }
};

Mendukung kunci akses

Dukungan keyboard bersifat integral untuk memastikan aplikasi Anda berfungsi dengan baik bagi pengguna dengan keterampilan, kemampuan, dan harapan yang berbeda. Kami menyarankan agar Anda mendukung kunci akselerator untuk navigasi maju dan balik karena pengguna yang mengandalkan ini akan mengharapkan keduanya. Untuk informasi selengkapnya, lihat Interaksi keyboard dan Akselerator keyboard.

Tombol akselerator umum untuk navigasi maju dan belakang adalah Alt+Panah kanan (maju) dan Alt+Panah kiri (kembali). Untuk mendukung kunci ini untuk navigasi, tangani peristiwa CoreDispatcher.AcceleratorKeyActivated . Anda menangani peristiwa yang langsung ada di Jendela (bukan elemen di halaman) sehingga aplikasi merespons kunci akselerator terlepas dari elemen mana yang memiliki fokus.

Tambahkan kode ke App kelas untuk mendukung kunci akselerator dan teruskan navigasi, seperti yang ditunjukkan di sini. (Ini mengasumsikan bahwa kode sebelumnya untuk mendukung tombol kembali telah ditambahkan.) Anda dapat melihat semua App kode bersama-sama di akhir bagian Contoh kode.

// App.xaml.cs
// Add event handler in OnLaunced.
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // ...
        // rootFrame.NavigationFailed += OnNavigationFailed;

        // Add support for accelerator keys. 
        // Listen to the window directly so the app responds
        // to accelerator keys regardless of which element has focus.
        Window.Current.CoreWindow.Dispatcher.AcceleratorKeyActivated +=
            CoreDispatcher_AcceleratorKeyActivated;

        // ...

    }
}

// ...

// Add this code after the TryGoBack method added previously.
// Perform forward navigation if possible.
private bool TryGoForward()
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoForward)
    {
        rootFrame.GoForward();
        return true;
    }
    return false;
}

// Invoked on every keystroke, including system keys such as Alt key combinations.
// Used to detect keyboard navigation between pages even when the page itself
// doesn't have focus.
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
    // When Alt+Left are pressed navigate back.
    // When Alt+Right are pressed navigate forward.
    if (e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown
        && (e.VirtualKey == VirtualKey.Left || e.VirtualKey == VirtualKey.Right)
        && e.KeyStatus.IsMenuKeyDown == true
        && !e.Handled)
    {
        if (e.VirtualKey == VirtualKey.Left)
        {
            e.Handled = TryGoBack();
        }
        else if (e.VirtualKey == VirtualKey.Right)
        {
            e.Handled = TryGoForward();
        }
    }
}

// App.cpp
void App::OnLaunched(LaunchActivatedEventArgs const& e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        // ...
        // rootFrame.NavigationFailed({ this, &App::OnNavigationFailed });

        // Add support for accelerator keys. 
        // Listen to the window directly so the app responds
        // to accelerator keys regardless of which element has focus.
        Window::Current().CoreWindow().Dispatcher().
            AcceleratorKeyActivated({ this, &App::CoreDispatcher_AcceleratorKeyActivated });

        // ...
    }
}

// App.h
struct App : AppT<App>
{
    App();

    // ...
    // Add this code after the TryGoBack method added previously.

private:
    // Perform forward navigation if possible.
    bool TryGoForward()
    {
        Frame rootFrame{ nullptr };
        auto content = Window::Current().Content();
        if (content)
        {
            rootFrame = content.try_as<Frame>();
            if (rootFrame.CanGoForward())
            {
                rootFrame.GoForward();
                return true;
            }
        }
        return false;
    }
 
 
    // Invoked on every keystroke, including system keys such as Alt key combinations.
    // Used to detect keyboard navigation between pages even when the page itself
    // doesn't have focus.
    void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher const& /* sender */, AcceleratorKeyEventArgs const& e)
    {
        // When Alt+Left are pressed navigate back.
        // When Alt+Right are pressed navigate forward.
        if (e.EventType() == CoreAcceleratorKeyEventType::SystemKeyDown
            && (e.VirtualKey() == Windows::System::VirtualKey::Left || e.VirtualKey() == Windows::System::VirtualKey::Right)
            && e.KeyStatus().IsMenuKeyDown
            && !e.Handled())
        {
            if (e.VirtualKey() == Windows::System::VirtualKey::Left)
            {
                e.Handled(TryGoBack());
            }
            else if (e.VirtualKey() == Windows::System::VirtualKey::Right)
            {
                e.Handled(TryGoForward());
            }
        }
    }
};

Menangani permintaan kembali sistem

Perangkat Windows menyediakan berbagai cara agar sistem dapat meneruskan kembali permintaan navigasi ke aplikasi Anda. Beberapa cara umum adalah tombol B pada gamepad, tombol Windows + pintasan kunci Backspace, atau tombol kembali sistem dalam Mode Tablet; opsi yang tepat tersedia tergantung pada perangkat.

Anda dapat mendukung permintaan kembali yang disediakan sistem dari kunci kembali sistem perangkat keras dan perangkat lunak dengan mendaftarkan pendengar untuk peristiwa SystemNavigationManager.BackRequested .

Berikut adalah kode yang ditambahkan ke App kelas untuk mendukung sistem yang menyediakan kembali permintaan. (Ini mengasumsikan bahwa kode sebelumnya untuk mendukung tombol kembali telah ditambahkan.) Anda dapat melihat semua App kode bersama-sama di akhir bagian Contoh kode.

// App.xaml.cs
// Add event handler in OnLaunced.
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // ...
        // Add support for accelerator keys. 
        // ... (Previously added code.)

        // Add support for system back requests. 
        SystemNavigationManager.GetForCurrentView().BackRequested 
            += System_BackRequested;

        // ...

    }
}

// ...
// Handle system back requests.
private void System_BackRequested(object sender, BackRequestedEventArgs e)
{
    if (!e.Handled)
    {
        e.Handled = TryGoBack();
    }
}

// App.cpp
void App::OnLaunched(LaunchActivatedEventArgs const& e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        // ...
        // Add support for accelerator keys. 
        // ... (Previously added code.)

        // Add support for system back requests. 
        SystemNavigationManager::GetForCurrentView().
            BackRequested({ this, &App::System_BackRequested });

        // ...
    }
}

// App.h
struct App : AppT<App>
{
    App();

    // ...

private:
    // ...

    // Handle system back requests.
    void System_BackRequested(IInspectable const& /* sender */, BackRequestedEventArgs const& e)
    {
        if (!e.Handled())
        {
            e.Handled(TryGoBack());
        }
    }
};

Perilaku mundur sistem untuk kompatibilitas mundur

Sebelumnya, aplikasi UWP menggunakan SystemNavigationManager.AppViewBackButtonVisibility untuk menampilkan atau menyembunyikan tombol kembali sistem untuk navigasi mundur. (Tombol ini menaikkan SystemNavigationManager.BackRequested event.) API ini akan terus didukung untuk memastikan kompatibilitas mundur, tetapi kami tidak lagi merekomendasikan menggunakan tombol kembali yang diekspos oleh AppViewBackButtonVisibility. Sebagai gantinya, Anda harus menyediakan tombol kembali dalam aplikasi Anda sendiri seperti yang dijelaskan dalam artikel ini.

Jika Anda terus menggunakan AppViewBackButtonVisibility, maka UI sistem merender tombol kembali sistem di dalam bilah judul. (Tampilan dan interaksi pengguna untuk tombol kembali tidak berubah dari build sebelumnya.)

Beberapa tikus menyediakan tombol navigasi perangkat keras untuk navigasi maju dan balik. Anda dapat mendukung tombol mouse ini dengan menangani peristiwa CoreWindow.PointerPressed dan memeriksa IsXButton1Pressed (kembali) atau IsXButton2Pressed (maju).

Berikut adalah kode yang ditambahkan ke App kelas untuk mendukung navigasi tombol mouse. (Ini mengasumsikan bahwa kode sebelumnya untuk mendukung tombol kembali telah ditambahkan.) Anda dapat melihat semua App kode bersama-sama di akhir bagian Contoh kode.

// App.xaml.cs
// Add event handler in OnLaunced.
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // ...
        // Add support for system back requests. 
        // ... (Previously added code.)

        // Add support for mouse navigation buttons. 
        Window.Current.CoreWindow.PointerPressed += CoreWindow_PointerPressed;

        // ...

    }
}

// ...

// Handle mouse back button.
private void CoreWindow_PointerPressed(CoreWindow sender, PointerEventArgs e)
{
    // For this event, e.Handled arrives as 'true'.
    if (e.CurrentPoint.Properties.IsXButton1Pressed)
    {
        e.Handled = !TryGoBack();
    }
    else if (e.CurrentPoint.Properties.IsXButton2Pressed)
    {
        e.Handled = !TryGoForward();
    }
}

// App.cpp
void App::OnLaunched(LaunchActivatedEventArgs const& e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        // ...
        // Add support for system back requests. 
        // ... (Previously added code.)

        // Add support for mouse navigation buttons. 
        Window::Current().CoreWindow().
            PointerPressed({ this, &App::CoreWindow_PointerPressed });

        // ...
    }
}

// App.h
struct App : AppT<App>
{
    App();

    // ...

private:
    // ...

    // Handle mouse forward and back buttons.
    void CoreWindow_PointerPressed(CoreWindow const& /* sender */, PointerEventArgs const& e)
    {
        // For this event, e.Handled arrives as 'true'. 
        if (e.CurrentPoint().Properties().IsXButton1Pressed())
        {
            e.Handled(!TryGoBack());
        }
        else if (e.CurrentPoint().Properties().IsXButton2Pressed())
        {
            e.Handled(!TryGoForward());
        }
    }
};

Semua kode ditambahkan ke kelas Aplikasi

// App.xaml.cs
//
// (Add event handlers in OnLaunched override.)
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // ...
        // rootFrame.NavigationFailed += OnNavigationFailed;

        // Add support for accelerator keys. 
        // Listen to the window directly so the app responds
        // to accelerator keys regardless of which element has focus.
        Window.Current.CoreWindow.Dispatcher.AcceleratorKeyActivated +=
            CoreDispatcher_AcceleratorKeyActivated;

        // Add support for system back requests. 
        SystemNavigationManager.GetForCurrentView().BackRequested 
            += System_BackRequested;

        // Add support for mouse navigation buttons. 
        Window.Current.CoreWindow.PointerPressed += CoreWindow_PointerPressed;

        // ...

    }
}

// ...

// (Add these methods to the App class.)
public static bool TryGoBack()
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoBack)
    {
        rootFrame.GoBack();
        return true;
    }
    return false;
}

// Perform forward navigation if possible.
private bool TryGoForward()
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoForward)
    {
        rootFrame.GoForward();
        return true;
    }
    return false;
}

// Invoked on every keystroke, including system keys such as Alt key combinations.
// Used to detect keyboard navigation between pages even when the page itself
// doesn't have focus.
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
    // When Alt+Left are pressed navigate back.
    // When Alt+Right are pressed navigate forward.
    if (e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown
        && (e.VirtualKey == VirtualKey.Left || e.VirtualKey == VirtualKey.Right)
        && e.KeyStatus.IsMenuKeyDown == true
        && !e.Handled)
    {
        if (e.VirtualKey == VirtualKey.Left)
        {
            e.Handled = TryGoBack();
        }
        else if (e.VirtualKey == VirtualKey.Right)
        {
            e.Handled = TryGoForward();
        }
    }
}

// Handle system back requests.
private void System_BackRequested(object sender, BackRequestedEventArgs e)
{
    if (!e.Handled)
    {
        e.Handled = TryGoBack();
    }
}

// Handle mouse back button.
private void CoreWindow_PointerPressed(CoreWindow sender, PointerEventArgs e)
{
    // For this event, e.Handled arrives as 'true'.
    if (e.CurrentPoint.Properties.IsXButton1Pressed)
    {
        e.Handled = !TryGoBack();
    }
    else if (e.CurrentPoint.Properties.IsXButton2Pressed)
    {
        e.Handled = !TryGoForward();
    }
}

// App.cpp
void App::OnLaunched(LaunchActivatedEventArgs const& e)
{
    // ...
    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        // ...
        // rootFrame.NavigationFailed({ this, &App::OnNavigationFailed });

        // Add support for accelerator keys. 
        // Listen to the window directly so the app responds
        // to accelerator keys regardless of which element has focus.
        Window::Current().CoreWindow().Dispatcher().
            AcceleratorKeyActivated({ this, &App::CoreDispatcher_AcceleratorKeyActivated });

        // Add support for system back requests. 
        SystemNavigationManager::GetForCurrentView().
            BackRequested({ this, &App::System_BackRequested });

        // Add support for mouse navigation buttons. 
        Window::Current().CoreWindow().
            PointerPressed({ this, &App::CoreWindow_PointerPressed });

        // ...
    }
}

// App.h
#include "winrt/Windows.UI.Core.h"
#include "winrt/Windows.System.h"
#include "winrt/Windows.UI.Input.h"
#include "winrt/Windows.UI.Xaml.Input.h"
 
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::UI::Core;
using namespace Windows::UI::Input;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;

struct App : AppT<App>
{
    App();

    // ...

    // Perform back navigation if possible.
    static bool TryGoBack()
    {
        Frame rootFrame{ nullptr };
        auto content = Window::Current().Content();
        if (content)
        {
            rootFrame = content.try_as<Frame>();
            if (rootFrame.CanGoBack())
            {
                rootFrame.GoBack();
                return true;
            }
        }
        return false;
    }
private:
    // Perform forward navigation if possible.
    bool TryGoForward()
    {
        Frame rootFrame{ nullptr };
        auto content = Window::Current().Content();
        if (content)
        {
            rootFrame = content.try_as<Frame>();
            if (rootFrame.CanGoForward())
            {
                rootFrame.GoForward();
                return true;
            }
        }
        return false;
    }
  
    // Invoked on every keystroke, including system keys such as Alt key combinations.
    // Used to detect keyboard navigation between pages even when the page itself
    // doesn't have focus.
    void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher const& /* sender */, AcceleratorKeyEventArgs const& e)
    {
        // When Alt+Left are pressed navigate back.
        // When Alt+Right are pressed navigate forward.
        if (e.EventType() == CoreAcceleratorKeyEventType::SystemKeyDown
            && (e.VirtualKey() == Windows::System::VirtualKey::Left || e.VirtualKey() == Windows::System::VirtualKey::Right)
            && e.KeyStatus().IsMenuKeyDown
            && !e.Handled())
        {
            if (e.VirtualKey() == Windows::System::VirtualKey::Left)
            {
                e.Handled(TryGoBack());
            }
            else if (e.VirtualKey() == Windows::System::VirtualKey::Right)
            {
                e.Handled(TryGoForward());
            }
        }
    }

    // Handle system back requests.
    void System_BackRequested(IInspectable const& /* sender */, BackRequestedEventArgs const& e)
    {
        if (!e.Handled())
        {
            e.Handled(TryGoBack());
        }
    }

    // Handle mouse forward and back buttons.
    void CoreWindow_PointerPressed(CoreWindow const& /* sender */, PointerEventArgs const& e)
    {
        // For this event, e.Handled arrives as 'true'. 
        if (e.CurrentPoint().Properties().IsXButton1Pressed())
        {
            e.Handled(!TryGoBack());
        }
        else if (e.CurrentPoint().Properties().IsXButton2Pressed())
        {
            e.Handled(!TryGoForward());
        }
    }
};

Jika Anda memilih untuk menyediakan navigasi tumpukan belakang Anda sendiri, pengalaman harus konsisten dengan aplikasi lain. Kami menyarankan agar Anda mengikuti pola berikut untuk tindakan navigasi:

Tindakan navigasi	Tambahkan ke riwayat navigasi?
Halaman ke halaman, grup serekan yang berbeda	Ya Dalam ilustrasi ini, pengguna menavigasi dari tingkat 1 aplikasi ke tingkat 2, melintasi grup serekan, sehingga navigasi ditambahkan ke riwayat navigasi. Dalam ilustrasi berikutnya, pengguna menavigasi antara dua grup serekan pada tingkat yang sama, sekali lagi melintasi grup serekan, sehingga navigasi ditambahkan ke riwayat navigasi.
Halaman ke halaman, grup serekan yang sama, tidak ada elemen navigasi di layar Pengguna menavigasi dari satu halaman ke halaman lain dengan grup serekan yang sama. Tidak ada elemen navigasi di layar (seperti NavigationView) yang menyediakan navigasi langsung ke kedua halaman.	Ya Dalam ilustrasi berikut, pengguna menavigasi antara dua halaman dalam grup serekan yang sama, dan navigasi harus ditambahkan ke riwayat navigasi.
Halaman ke halaman, grup serekan yang sama, dengan elemen navigasi di layar Pengguna menavigasi dari satu halaman ke halaman lain dalam grup serekan yang sama. Kedua halaman ditampilkan dalam elemen navigasi yang sama, seperti NavigationView.	Itu tergantung Ya, tambahkan ke riwayat navigasi, dengan dua pengecualian penting. Jika Anda mengharapkan pengguna aplikasi Anda sering beralih antar halaman dalam grup serekan, atau jika Anda ingin mempertahankan hierarki navigasi, jangan tambahkan ke riwayat navigasi. Dalam hal ini, ketika pengguna menekan kembali, kembali ke halaman terakhir sebelum pengguna menavigasi ke grup serekan saat ini.
Perlihatkan UI sementara Aplikasi menampilkan jendela pop-up atau anak, seperti dialog, layar splash, atau keyboard di layar, atau aplikasi memasuki mode khusus, seperti mode pilihan ganda.	Tidak Ketika pengguna menekan tombol kembali, matikan UI sementara (sembunyikan keyboard di layar, batalkan dialog, dll) dan kembali ke halaman yang menelurkan UI sementara.
Menghitung item Aplikasi menampilkan konten untuk item di layar, seperti detail untuk item yang dipilih dalam daftar/daftar detail.	Tidak Menghitung item mirip dengan menavigasi dalam grup serekan. Ketika pengguna menekan kembali, navigasikan ke halaman yang mendahului halaman saat ini yang memiliki enumerasi item.