Xamarin.Forms w projektach natywnych platformy Xamarin

Xamarin.Forms Zazwyczaj aplikacja zawiera co najmniej jedną stronę pochodzącą z ContentPageprogramu , a te strony są współużytkowane przez wszystkie platformy w projekcie biblioteki platformy .NET Standard lub udostępnionym projekcie. Jednak formularze ContentPagenatywne umożliwiają dodawanie stron pochodnych bezpośrednio do natywnych aplikacji Xamarin.iOS, Xamarin.Android i UWP. W porównaniu z używaniem stron ContentPagepochodnych projektu natywnego z projektu biblioteki platformy .NET Standard lub projektu udostępnionego zaletą dodawania stron bezpośrednio do projektów natywnych jest to, że strony mogą być rozszerzane przy użyciu widoków natywnych. Widoki natywne mogą być następnie nazwane w języku XAML x:Name i przywoływane z kodu. Aby uzyskać więcej informacji na temat widoków natywnych, zobacz Widoki natywne.

Proces korzystania ze strony pochodnej Xamarin.FormsContentPagew projekcie natywnym jest następujący:

1. Xamarin.Forms Dodaj pakiet NuGet do projektu natywnego.
2. Dodaj stronę pochodną ContentPagei wszystkie zależności do projektu natywnego.
3. Wywołaj metodę Forms.Init .
4. Skonstruuj wystąpienie strony pochodnej ContentPagei przekonwertuj je na odpowiedni typ macierzysty przy użyciu jednej z następujących metod rozszerzenia: CreateViewController dla systemu iOS, CreateSupportFragment dla systemu Android lub CreateFrameworkElement platformy UWP.
5. Przejdź do natywnej reprezentacji typu strony pochodnej ContentPageprzy użyciu natywnego interfejsu API nawigacji.

Xamarin.Forms Należy zainicjować metodę Forms.Init , wywołując metodę, zanim projekt natywny może utworzyć stronę pochodną ContentPage. Wybór, kiedy to zrobić, zależy przede wszystkim od tego, kiedy jest on najbardziej wygodny w przepływie aplikacji — można go wykonać podczas uruchamiania aplikacji lub tuż przed skonstruowaniem strony pochodnej ContentPage. W tym artykule i towarzyszących przykładowych aplikacjach metoda jest wywoływana Forms.Init podczas uruchamiania aplikacji.

Uwaga

Przykładowe rozwiązanie aplikacji NativeForms nie zawiera żadnych Xamarin.Forms projektów. Zamiast tego składa się z projektu platformy Xamarin.iOS, projektu platformy Xamarin.Android i projektu platformy UWP. Każdy projekt jest projektem natywnym, który używa formularzy natywnych do korzystania ze ContentPagestron pochodnych. Nie ma jednak powodu, dla którego projekty natywne nie mogły korzystać ContentPageze stron pochodnych z projektu biblioteki .NET Standard ani projektu udostępnionego.

W przypadku korzystania z formularzy natywnych funkcje, Xamarin.Forms takie jak DependencyService, MessagingCenteri aparat powiązania danych, nadal działają. Jednak nawigacja po stronie musi być wykonywana przy użyciu natywnego interfejsu API nawigacji.

iOS

W FinishedLaunching systemie iOS przesłonięcia w AppDelegate klasie to zazwyczaj miejsce do wykonywania zadań związanych z uruchamianiem aplikacji. Jest wywoływana po uruchomieniu aplikacji i jest zwykle zastępowana w celu skonfigurowania głównego okna i kontrolera widoku. Poniższy przykład kodu przedstawia klasę AppDelegate w przykładowej aplikacji:

[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
    public static AppDelegate Instance;
    UIWindow _window;
    AppNavigationController _navigation;

    public static string FolderPath { get; private set; }

    public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
    {
        Forms.Init();

        // Create app-level resource dictionary.
        Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
        Xamarin.Forms.Application.Current.Resources = new MyDictionary();

        Instance = this;
        _window = new UIWindow(UIScreen.MainScreen.Bounds);

        UINavigationBar.Appearance.SetTitleTextAttributes(new UITextAttributes
        {
            TextColor = UIColor.Black
        });

        FolderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));

        NotesPage notesPage = new NotesPage()
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };

        UIViewController notesPageController = notesPage.CreateViewController();
        notesPageController.Title = "Notes";

        _navigation = new AppNavigationController(notesPageController);

        _window.RootViewController = _navigation;
        _window.MakeKeyAndVisible();

        notesPage.Parent = null;
        return true;
    }
    // ...
}

Metoda FinishedLaunching wykonuje następujące zadania:

• Xamarin.Forms metoda jest inicjowana przez wywołanie Forms.Init metody .
• Tworzony jest nowy Xamarin.Forms.Application obiekt, a jego słownik zasobów na poziomie aplikacji jest ustawiony na ResourceDictionary określony w języku XAML.
• Odwołanie do AppDelegate klasy jest przechowywane w static Instance polu. Ma to na celu zapewnienie mechanizmu dla innych klas w celu wywołania metod zdefiniowanych w AppDelegate klasie.
• Zostanie UIWindowutworzony kontener , który jest głównym kontenerem dla widoków w natywnych aplikacjach systemu iOS.
• Właściwość FolderPath jest inicjowana do ścieżki na urządzeniu, na którym będą przechowywane dane notatek.
• Obiekt NotesPage jest tworzony, który jest stroną pochodną zdefiniowaną Xamarin.FormsContentPagew języku XAML, a jego element nadrzędny jest ustawiony na wcześniej utworzony Xamarin.Forms.Application obiekt.
• Obiekt NotesPage jest konwertowany na metodę UIViewController CreateViewController rozszerzenia przy użyciu metody .
• Właściwość Title UIViewController właściwości jest ustawiona, która będzie wyświetlana w obiekcie UINavigationBar.
• Element jest AppNavigationController tworzony do zarządzania nawigacją hierarchiczną. Jest to niestandardowa klasa kontrolera nawigacji, która pochodzi z UINavigationControllerklasy . Obiekt AppNavigationController zarządza stosem kontrolerów widoku, a UIViewController przekazany do konstruktora zostanie przedstawiony początkowo po załadowaniu AppNavigationController .
• Obiekt AppNavigationController jest ustawiany jako najwyższy poziom UIViewController dla UIWindowelementu , a UIWindow element jest ustawiany jako okno klucza dla aplikacji i jest widoczny.
• Właściwość Parent NotesPage obiektu jest ustawiona na null, aby zapobiec wyciekowi pamięci.

Po wykonaniu FinishedLaunching metody zostanie wyświetlony interfejs użytkownika zdefiniowany w Xamarin.FormsNotesPage klasie, jak pokazano na poniższym zrzucie ekranu:

Ważne

Wszystkie ContentPagestrony pochodne mogą korzystać z zasobów zdefiniowanych na poziomie ResourceDictionaryaplikacji, pod warunkiem, że Parent właściwość strony jest ustawiona Application na obiekt.

Interakcja z interfejsem użytkownika, na przykład przez naciśnięcie + Buttonprzycisku , spowoduje wykonanie następującego programu obsługi zdarzeń w NotesPage kodzie wykonywanym:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    AppDelegate.Instance.NavigateToNoteEntryPage(new Note());
}

Pole static AppDelegate.Instance umożliwia AppDelegate.NavigateToNoteEntryPage wywołanie metody, która jest pokazana w poniższym przykładzie kodu:

public void NavigateToNoteEntryPage(Note note)
{
    NoteEntryPage noteEntryPage = new NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };

    var noteEntryViewController = noteEntryPage.CreateViewController();
    noteEntryViewController.Title = "Note Entry";

    _navigation.PushViewController(noteEntryViewController, true);
    noteEntryPage.Parent = null;
}

Metoda NavigateToNoteEntryPage konwertuje stronę pochodną Xamarin.FormsContentPagena obiekt UIViewController za pomocą CreateViewController metody rozszerzenia i ustawia Title właściwość UIViewController. Element UIViewController jest następnie wypychany przez AppNavigationController metodę PushViewController . W związku z tym zostanie wyświetlony interfejs użytkownika zdefiniowany w Xamarin.FormsNoteEntryPage klasie, jak pokazano na poniższym zrzucie ekranu:

Po wyświetleniu NoteEntryPage elementu nawigacja wsteczna wyświetli element UIViewController dla NoteEntryPage klasy z AppNavigationControllerklasy , zwracając użytkownika do UIViewController NotesPage klasy . Jednak wyskakujące okienko UIViewController z natywnego stosu nawigacji systemu iOS nie powoduje automatycznego usunięcia obiektu i dołączonego UIViewController Page obiektu. AppNavigationController W związku z tym klasa zastępuje metodę PopViewController , aby usunąć kontrolery widoku na nawigacji wstecznej:

public class AppNavigationController : UINavigationController
{
    //...
    public override UIViewController PopViewController(bool animated)
    {
        UIViewController topView = TopViewController;
        if (topView != null)
        {
            // Dispose of ViewController on back navigation.
            topView.Dispose();
        }
        return base.PopViewController(animated);
    }
}

Przesłonięcia PopViewController wywołuje metodę Dispose w UIViewController obiekcie, który został wyświetlony z natywnego stosu nawigacji systemu iOS. Wykonanie tej czynności spowoduje UIViewController , że obiekt i dołączonego Page obiektu zostaną oddzielone.

Ważne

Oddzielone obiekty nie mogą być wyrzucane śmieci, co powoduje wyciek pamięci.

Android

W systemie Android OnCreate przesłonięcia w MainActivity klasie to zazwyczaj miejsce do wykonywania zadań związanych z uruchamianiem aplikacji. Poniższy przykład kodu przedstawia klasę MainActivity w przykładowej aplikacji:

public class MainActivity : AppCompatActivity
{
    public static string FolderPath { get; private set; }

    public static MainActivity Instance;

    protected override void OnCreate(Bundle bundle)
    {
        base.OnCreate(bundle);

        Forms.Init(this, bundle);

        // Create app-level resource dictionary.
        Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
        Xamarin.Forms.Application.Current.Resources = new MyDictionary();

        Instance = this;

        SetContentView(Resource.Layout.Main);
        var toolbar = FindViewById<Toolbar>(Resource.Id.toolbar);
        SetSupportActionBar(toolbar);
        SupportActionBar.Title = "Notes";

        FolderPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData));

        NotesPage notesPage = new NotesPage()
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };
        AndroidX.Fragment.App.Fragment notesPageFragment = notesPage.CreateSupportFragment(this);

        SupportFragmentManager
            .BeginTransaction()
            .Replace(Resource.Id.fragment_frame_layout, mainPage)
            .Commit();
        //...

        notesPage.Parent = null;
    }
    ...
}

Metoda OnCreate wykonuje następujące zadania:

• Xamarin.Forms metoda jest inicjowana przez wywołanie Forms.Init metody .
• Tworzony jest nowy Xamarin.Forms.Application obiekt, a jego słownik zasobów na poziomie aplikacji jest ustawiony na ResourceDictionary określony w języku XAML.
• Odwołanie do MainActivity klasy jest przechowywane w static Instance polu. Ma to na celu zapewnienie mechanizmu dla innych klas w celu wywołania metod zdefiniowanych w MainActivity klasie.
• Zawartość Activity jest ustawiana na podstawie zasobu układu. W przykładowej aplikacji układ składa się z elementu LinearLayout , Toolbarktóry zawiera element , i element FrameLayout do działania jako kontener fragmentu.
• Element Toolbar jest pobierany i ustawiany jako pasek akcji dla Activityelementu , a tytuł paska akcji jest ustawiony.
• Właściwość FolderPath jest inicjowana do ścieżki na urządzeniu, na którym będą przechowywane dane notatek.
• Obiekt NotesPage jest tworzony, który jest stroną pochodną zdefiniowaną Xamarin.FormsContentPagew języku XAML, a jego element nadrzędny jest ustawiony na wcześniej utworzony Xamarin.Forms.Application obiekt.
• Obiekt NotesPage jest konwertowany na metodę Fragment CreateSupportFragment rozszerzenia przy użyciu metody .
• Klasa SupportFragmentManager tworzy i zatwierdza transakcję, która zastępuje FrameLayout wystąpienie klasą Fragment NotesPage .
• Właściwość Parent NotesPage obiektu jest ustawiona na null, aby zapobiec wyciekowi pamięci.

Aby uzyskać więcej informacji na temat fragmentów, zobacz Fragments (Fragmenty).

Po wykonaniu OnCreate metody zostanie wyświetlony interfejs użytkownika zdefiniowany w Xamarin.FormsNotesPage klasie, jak pokazano na poniższym zrzucie ekranu:

Ważne

Wszystkie ContentPagestrony pochodne mogą korzystać z zasobów zdefiniowanych na poziomie ResourceDictionaryaplikacji, pod warunkiem, że Parent właściwość strony jest ustawiona Application na obiekt.

Interakcja z interfejsem użytkownika, na przykład przez naciśnięcie + Buttonprzycisku , spowoduje wykonanie następującego programu obsługi zdarzeń w NotesPage kodzie wykonywanym:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    MainActivity.Instance.NavigateToNoteEntryPage(new Note());
}

Pole static MainActivity.Instance umożliwia MainActivity.NavigateToNoteEntryPage wywołanie metody, która jest pokazana w poniższym przykładzie kodu:

public void NavigateToNoteEntryPage(Note note)
{
    NoteEntryPage noteEntryPage = new NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };

    AndroidX.Fragment.App.Fragment noteEntryFragment = noteEntryPage.CreateSupportFragment(this);
    SupportFragmentManager
        .BeginTransaction()
        .AddToBackStack(null)
        .Replace(Resource.Id.fragment_frame_layout, noteEntryFragment)
        .Commit();

    noteEntryPage.Parent = null;
}

Metoda NavigateToNoteEntryPage konwertujeContentPageXamarin.Forms stronę pochodną na obiekt Fragment za pomocą CreateSupportFragment metody rozszerzenia i dodaje element Fragment do stosu wstecznego fragmentu. W związku z tym zostanie wyświetlony interfejs użytkownika zdefiniowany w elemecie Xamarin.FormsNoteEntryPage , jak pokazano na poniższym zrzucie ekranu:

NoteEntryPage Po wyświetleniu elementu naciśnięcie strzałki wstecz spowoduje wyświetlenie Fragment przycisku dla NoteEntryPage stosu wstecz fragmentu, zwracając użytkownika do Fragment NotesPage klasy .

Włączanie obsługi nawigacji wstecznej

Klasa SupportFragmentManager ma BackStackChanged zdarzenie, które jest uruchamiane za każdym razem, gdy zawartość stosu wstecznego fragmentu ulegnie zmianie. Metoda OnCreate w MainActivity klasie zawiera anonimową procedurę obsługi zdarzeń dla tego zdarzenia:

SupportFragmentManager.BackStackChanged += (sender, e) =>
{
    bool hasBack = SupportFragmentManager.BackStackEntryCount > 0;
    SupportActionBar.SetHomeButtonEnabled(hasBack);
    SupportActionBar.SetDisplayHomeAsUpEnabled(hasBack);
    SupportActionBar.Title = hasBack ? "Note Entry" : "Notes";
};

Ten program obsługi zdarzeń wyświetla przycisk Wstecz na pasku akcji, pod warunkiem, że istnieje co najmniej jedno Fragment wystąpienie na stosie wstecz fragmentu. Odpowiedź na naciśnięcie przycisku Wstecz jest obsługiwana OnOptionsItemSelected przez zastąpienie:

public override bool OnOptionsItemSelected(Android.Views.IMenuItem item)
{
    if (item.ItemId == global::Android.Resource.Id.Home && SupportFragmentManager.BackStackEntryCount > 0)
    {
        SupportFragmentManager.PopBackStack();
        return true;
    }
    return base.OnOptionsItemSelected(item);
}

Przesłonięcia OnOptionsItemSelected są wywoływane za każdym razem, gdy zostanie wybrany element w menu opcji. Ta implementacja powoduje wyskakujące bieżący fragment z stosu wstecz fragmentu, pod warunkiem, że przycisk Wstecz został wybrany i istnieje co najmniej jedno Fragment wystąpienie na stosie wstecz fragmentu.

Wiele działań

Gdy aplikacja składa się z wielu działań, ContentPagestrony pochodne można osadzać w każdym z działań. W tym scenariuszu Forms.Init metoda musi być wywoływana tylko w OnCreate zastąpieniu pierwszego Activity , który osadza Xamarin.FormsContentPageelement . Ma to jednak następujący wpływ:

• Wartość parametru Xamarin.Forms.Color.Accent zostanie pobrana z Activity metody , która nazwała metodę Forms.Init .
• Wartość parametru Xamarin.Forms.Application.Current zostanie skojarzona z Activity wywołaną Forms.Init metodą .

Wybierz plik

W przypadku osadzania strony pochodnej ContentPageużywającej elementu WebView , który wymaga obsługi przycisku "Wybierz plik" HTML, Activity należy zastąpić metodę OnActivityResult :

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);
    ActivityResultCallbackRegistry.InvokeCallback(requestCode, resultCode, data);
}

Platforma UWP

W przypadku platformy UWP klasa natywna App jest zazwyczaj miejscem do wykonywania zadań związanych z uruchamianiem aplikacji. Xamarin.Forms jest zwykle inicjowany w Xamarin.Forms aplikacjach platformy UWP w OnLaunched przesłonięć w klasie natywnej App , aby przekazać LaunchActivatedEventArgs argument do Forms.Init metody . Z tego powodu natywne aplikacje platformy UNIWERSALNEJ systemu Windows, które korzystają Xamarin.FormsContentPageze strony pochodnej, można najłatwiej wywołać metodę Forms.Init z App.OnLaunched metody :

protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    Xamarin.Forms.Forms.Init(e);

    // Create app-level resource dictionary.
    Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
    Xamarin.Forms.Application.Current.Resources = new MyDictionary();

    // ...
}

Ponadto OnLaunched metoda może również utworzyć dowolny słownik zasobów na poziomie aplikacji, który jest wymagany przez aplikację.

Domyślnie klasa natywna App uruchamia klasę MainPage jako pierwszą stronę aplikacji. Poniższy przykład kodu przedstawia klasę MainPage w przykładowej aplikacji:

public sealed partial class MainPage : Page
{
    NotesPage notesPage;
    NoteEntryPage noteEntryPage;

    public static MainPage Instance;
    public static string FolderPath { get; private set; }

    public MainPage()
    {
        this.NavigationCacheMode = NavigationCacheMode.Enabled;
        Instance = this;
        FolderPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData));

        notesPage = new Notes.UWP.Views.NotesPage
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };
        this.Content = notesPage.CreateFrameworkElement();
        // ...
        notesPage.Parent = null;    
    }
    // ...
}

Konstruktor MainPage wykonuje następujące zadania:

• Buforowanie jest włączone dla strony, aby nie było tworzone nowe MainPage , gdy użytkownik przechodzi z powrotem do strony.
• Odwołanie do MainPage klasy jest przechowywane w static Instance polu. Ma to na celu zapewnienie mechanizmu dla innych klas w celu wywołania metod zdefiniowanych w MainPage klasie.
• Właściwość FolderPath jest inicjowana do ścieżki na urządzeniu, na którym będą przechowywane dane notatek.
• Obiekt NotesPage jest tworzony, który jest stroną pochodną zdefiniowaną Xamarin.FormsContentPagew języku XAML, a jego element nadrzędny jest ustawiony na wcześniej utworzony Xamarin.Forms.Application obiekt.
• Obiekt NotesPage jest konwertowany na metodę FrameworkElement CreateFrameworkElement rozszerzenia przy użyciu, a następnie ustawiany jako zawartość MainPage klasy.
• Właściwość Parent NotesPage obiektu jest ustawiona na null, aby zapobiec wyciekowi pamięci.

Po wykonaniu konstruktora MainPage zostanie wyświetlony interfejs użytkownika zdefiniowany w Xamarin.FormsNotesPage klasie, jak pokazano na poniższym zrzucie ekranu:

Ważne

Wszystkie ContentPagestrony pochodne mogą korzystać z zasobów zdefiniowanych na poziomie ResourceDictionaryaplikacji, pod warunkiem, że Parent właściwość strony jest ustawiona Application na obiekt.

Interakcja z interfejsem użytkownika, na przykład przez naciśnięcie + Buttonprzycisku , spowoduje wykonanie następującego programu obsługi zdarzeń w NotesPage kodzie wykonywanym:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    MainPage.Instance.NavigateToNoteEntryPage(new Note());
}

Pole static MainPage.Instance umożliwia MainPage.NavigateToNoteEntryPage wywołanie metody, która jest pokazana w poniższym przykładzie kodu:

public void NavigateToNoteEntryPage(Note note)
{
    noteEntryPage = new Notes.UWP.Views.NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };
    this.Frame.Navigate(noteEntryPage);
    noteEntryPage.Parent = null;
}

Nawigacja w systemie UWP jest zwykle wykonywana przy Frame.Navigate użyciu metody , która przyjmuje Page argument. Xamarin.Forms definiuje metodę Frame.Navigate rozszerzenia, która przyjmuje wystąpienie strony pochodnej ContentPage. W związku z tym po wykonaniu NavigateToNoteEntryPage metody zostanie wyświetlony interfejs użytkownika zdefiniowany w Xamarin.FormsNoteEntryPage obiekcie , jak pokazano na poniższym zrzucie ekranu:

NoteEntryPage Po wyświetleniu elementu naciśnięcie strzałki wstecz spowoduje wyświetlenie FrameworkElement przycisku dla NoteEntryPage stosu wstecz w aplikacji, zwracając użytkownika do FrameworkElement NotesPage klasy .

Włączanie obsługi zmiany rozmiaru strony

Po zmianie rozmiaru Xamarin.Forms okna aplikacji platformy UNIWERSALNEJ należy również zmienić rozmiar zawartości. Jest to realizowane przez zarejestrowanie programu obsługi zdarzeń dla Loaded zdarzenia w konstruktorze MainPage :

public MainPage()
{
    // ...
    this.Loaded += OnMainPageLoaded;
    // ...
}

Zdarzenie Loaded jest uruchamiane, gdy strona jest ułożone, renderowane i gotowe do interakcji, i wykonuje metodę OnMainPageLoaded w odpowiedzi:

void OnMainPageLoaded(object sender, RoutedEventArgs e)
{
    this.Frame.SizeChanged += (o, args) =>
    {
        if (noteEntryPage != null)
            noteEntryPage.Layout(new Xamarin.Forms.Rectangle(0, 0, args.NewSize.Width, args.NewSize.Height));
        else
            notesPage.Layout(new Xamarin.Forms.Rectangle(0, 0, args.NewSize.Width, args.NewSize.Height));
    };
}

Metoda OnMainPageLoaded rejestruje anonimową procedurę obsługi zdarzeń dla Frame.SizeChanged zdarzenia, które jest wywoływane, gdy ActualHeight właściwości lub ActualWidth zmieniają się w obiekcie Frame. W odpowiedzi Xamarin.Forms rozmiar zawartości aktywnej strony jest zmieniany przez wywołanie Layout metody .

Włączanie obsługi nawigacji wstecznej

W systemie UWP aplikacje muszą włączyć nawigację wstecz dla wszystkich przycisków zwrotnych sprzętu i oprogramowania w różnych czynnikach formularzy urządzeń. Można to zrobić, rejestrując program obsługi zdarzeń dla BackRequested zdarzenia, który można wykonać w konstruktorze MainPage :

public MainPage()
{
    // ...
    SystemNavigationManager.GetForCurrentView().BackRequested += OnBackRequested;
}

Po uruchomieniu GetForCurrentView aplikacji metoda pobiera SystemNavigationManager obiekt skojarzony z bieżącym widokiem, a następnie rejestruje program obsługi zdarzeń dla BackRequested zdarzenia. Aplikacja odbiera to zdarzenie tylko wtedy, gdy jest to aplikacja pierwszego planu, a w odpowiedzi wywołuje procedurę OnBackRequested obsługi zdarzeń:

void OnBackRequested(object sender, BackRequestedEventArgs e)
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoBack)
    {
        e.Handled = true;
        rootFrame.GoBack();
        noteEntryPage = null;
    }
}

Procedura OnBackRequested obsługi zdarzeń wywołuje metodę GoBack w ramce głównej aplikacji i ustawia BackRequestedEventArgs.Handled właściwość na , aby oznaczyć true zdarzenie jako obsługiwane. Nie można oznaczyć zdarzenia jako obsłużonego, może spowodować zignorowanie zdarzenia.

Aplikacja wybiera, czy na pasku tytułu ma być wyświetlany przycisk Wstecz. Jest to osiągane przez ustawienie AppViewBackButtonVisibility właściwości na jedną z AppViewBackButtonVisibility wartości wyliczenia w App klasie:

void OnNavigated(object sender, NavigationEventArgs e)
{
    SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
        ((Frame)sender).CanGoBack ? AppViewBackButtonVisibility.Visible : AppViewBackButtonVisibility.Collapsed;
}

Procedura OnNavigated obsługi zdarzeń, która jest wykonywana w odpowiedzi na Navigated wyzwalanie zdarzenia, aktualizuje widoczność przycisku wstecz paska tytułu, gdy nastąpi nawigacja po stronie. Dzięki temu przycisk wstecz paska tytułu jest widoczny, jeśli stos zaplecza w aplikacji nie jest pusty lub usunięty z paska tytułu, jeśli stos zaplecza w aplikacji jest pusty.

Aby uzyskać więcej informacji na temat obsługi nawigacji wstecznej na platformie UWP, zobacz Historia nawigacji i nawigacja wstecz dla aplikacji platformy UWP.

Pokrewne łącza

• Widoki natywne