Xamarin.Forms in nativen Xamarin-Projekten

  • Artikel

Beispiel herunterladen Das Beispiel herunterladen

In der Regel enthält eine Xamarin.Forms Anwendung eine oder mehrere Seiten, die von ContentPageabgeleitet sind, und diese Seiten werden von allen Plattformen in einem .NET Standard-Bibliotheksprojekt oder einem freigegebenen Projekt gemeinsam genutzt. Native Forms ermöglicht ContentPagejedoch das direkte Hinzufügen von abgeleiteten Seiten zu nativen Xamarin.iOS-, Xamarin.Android- und UWP-Anwendungen. Im Vergleich dazu, dass das native Projekt abgeleitete Seiten aus einem .NET Standard-Bibliotheksprojekt oder einem freigegebenen Projekt verwendet ContentPage, besteht der Vorteil des direkten Hinzufügens von Seiten zu nativen Projekten darin, dass die Seiten mit nativen Ansichten erweitert werden können. Systemeigene Ansichten können dann in XAML mit x:Name benannt und vom CodeBehind aus referenziert werden. Weitere Informationen zu nativen Ansichten finden Sie unter Native Ansichten.

Der Prozess zum Verwenden einer Xamarin.FormsContentPageabgeleiteten Seite in einem nativen Projekt sieht wie folgt aus:

  1. Fügen Sie dem nativen Projekt das Xamarin.Forms NuGet-Paket hinzu.
  2. Fügen Sie dem nativen Projekt die ContentPageabgeleitete Seite und alle Abhängigkeiten hinzu.
  3. Rufen Sie die Forms.Init-Methode auf.
  4. Erstellen Sie eine instance der ContentPageabgeleiteten Seite, und konvertieren Sie sie mithilfe einer der folgenden Erweiterungsmethoden in den entsprechenden nativen Typ: CreateViewController für iOS, CreateSupportFragment für Android oder CreateFrameworkElement für UWP.
  5. Navigieren Sie mithilfe der nativen Navigations-API zur nativen Typdarstellung der ContentPageabgeleiteten Seite.

Xamarin.Forms muss durch Aufrufen der Forms.Init -Methode initialisiert werden, bevor ein systemeigenes Projekt eine ContentPageabgeleitete Seite erstellen kann. Die Entscheidung, wann dies erfolgen soll, hängt in erster Linie davon ab, wann dies in Ihrem Anwendungsfluss am bequemsten ist – er kann beim Anwendungsstart oder kurz vor dem Erstellen der ContentPageabgeleiteten Seite ausgeführt werden. In diesem Artikel und den zugehörigen Beispielanwendungen wird die Forms.Init -Methode beim Anwendungsstart aufgerufen.

Hinweis

Die NativeForms-Beispielanwendungslösung enthält keine Xamarin.Forms Projekte. Stattdessen besteht es aus einem Xamarin.iOS-Projekt, einem Xamarin.Android-Projekt und einem UWP-Projekt. Jedes Projekt ist ein natives Projekt, das native Formulare verwendet, um abgeleitete Seiten zu nutzen ContentPage. Es gibt jedoch keinen Grund, warum die nativen Projekte keine von einem .NET Standard-Bibliotheksprojekt oder einem freigegebenen Projekt abgeleiteten Seiten nutzen ContentPagekonnten.

Bei Verwendung von nativen Formularen Xamarin.Forms funktionieren Funktionen wie DependencyService, MessagingCenterund die Datenbindungs-Engine weiterhin. Die Seitennavigation muss jedoch mithilfe der nativen Navigations-API ausgeführt werden.

iOS

Unter iOS ist die FinishedLaunching Außerkraftsetzung in der Klasse in der AppDelegate Regel der Ort, an dem Aufgaben im Zusammenhang mit dem Anwendungsstart ausgeführt werden. Sie wird aufgerufen, nachdem die Anwendung gestartet wurde, und wird in der Regel überschrieben, um das Standard Fenster und den Ansichtscontroller zu konfigurieren. Das folgende Codebeispiel zeigt die AppDelegate -Klasse in der Beispielanwendung:

[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;
    }
    // ...
}

Die Methode FinishedLaunching führt die folgenden Aufgaben aus:

  • Xamarin.Forms wird durch Aufrufen der Forms.Init -Methode initialisiert.
  • Ein neues Xamarin.Forms.Application ist -Objekt wird erstellt, und sein Ressourcenverzeichnis auf Anwendungsebene wird auf ein ResourceDictionary festgelegt, das in XAML definiert ist.
  • Im Feld wird ein Verweis auf die AppDelegatestaticInstance -Klasse gespeichert. Dadurch wird ein Mechanismus bereitgestellt, mit dem andere Klassen methoden aufrufen können, die in der AppDelegate -Klasse definiert sind.
  • Die UIWindow, die der Standard Container für Ansichten in nativen iOS-Anwendungen ist, wird erstellt.
  • Die FolderPath -Eigenschaft wird in einen Pfad auf dem Gerät initialisiert, in dem Notizdaten gespeichert werden.
  • Es NotesPage wird ein -Objekt erstellt, bei dem es sich um eine Xamarin.FormsContentPagein XAML definierte abgeleitete Seite handelt, und das übergeordnete Element wird auf das zuvor erstellte Xamarin.Forms.Application Objekt festgelegt.
  • Das NotesPage -Objekt wird mithilfe der CreateViewController Erweiterungsmethode in ein UIViewController konvertiert.
  • Die Title -Eigenschaft von UIViewController ist festgelegt, die im UINavigationBarangezeigt wird.
  • Ein AppNavigationController wird für die Verwaltung der hierarchischen Navigation erstellt. Dies ist eine benutzerdefinierte Navigationscontrollerklasse, die von UINavigationControllerabgeleitet wird. Das AppNavigationController -Objekt verwaltet einen Stapel von Ansichtscontrollern, und das UIViewController an den Konstruktor übergebene wird zunächst angezeigt, wenn geladen AppNavigationController wird.
  • Das AppNavigationController -Objekt wird als oberste Ebene UIViewController für UIWindowfestgelegt, und das UIWindow wird als Schlüsselfenster für die Anwendung festgelegt und sichtbar gemacht.
  • Die Parent -Eigenschaft des NotesPage -Objekts wird auf nullfestgelegt, um einen Speicherverlust zu verhindern.

Nachdem die FinishedLaunching Methode ausgeführt wurde, wird die in der Xamarin.FormsNotesPage -Klasse definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

zeigt einen Notizenbildschirm auf einem mobilen Gerät.

Wichtig

Alle ContentPageabgeleiteten Seiten können Ressourcen nutzen, die in der Anwendungsebene ResourceDictionarydefiniert sind, vorausgesetzt, dass die Parent -Eigenschaft der Seite auf das Application -Objekt festgelegt ist.

Wenn Sie mit der Benutzeroberfläche interagieren, z. B. durch Tippen auf +Button, wird der folgende Ereignishandler in der NotesPage CodeBehind-Ausführung ausgeführt:

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

Das staticAppDelegate.Instance -Feld ermöglicht das Aufrufen der AppDelegate.NavigateToNoteEntryPage -Methode, was im folgenden Codebeispiel gezeigt wird:

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

Die NavigateToNoteEntryPage -Methode konvertiert die Xamarin.FormsContentPage-abgeleitete Seite mit der CreateViewController Erweiterungsmethode in ein UIViewController und legt die Title -Eigenschaft des UIViewControllerfest. Die UIViewController wird dann von der PushViewController -Methode an AppNavigationController gepusht. Daher wird die in der Xamarin.FormsNoteEntryPage -Klasse definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

Screenshot zeigt einen Hinweiseintrag auf einem mobilen Gerät.

Wenn die NoteEntryPage angezeigt wird, wird die Zurücknavigation für UIViewController die NoteEntryPage -Klasse aus AppNavigationControllerder -Klasse auffüllen, wodurch der Benutzer zu der UIViewController für die NotesPage Klasse zurückgibt. Das Popping eines UIViewController aus dem nativen iOS-Navigationsstapel führt jedoch nicht automatisch zum Verwerfen des und des UIViewController angefügten Page Objekts. Daher überschreibt die AppNavigationController -Klasse die PopViewController -Methode, um Ansichtscontroller bei der Rückwärtsnavigation zu verwerfen:

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

Die PopViewController -Außerkraftsetzung ruft die Dispose -Methode für das UIViewController Objekt auf, das aus dem nativen iOS-Navigationsstapel übertragen wurde. Andernfalls wird das UIViewController angefügte Page Objekt und verwaist.

Wichtig

Verwaiste Objekte können nicht mit Garbage Collection erfasst werden, sodass es zu einem Speicherverlust kommen kann.

Android

Unter Android ist die OnCreate Außerkraftsetzung in der Klasse in der MainActivity Regel der Ort, um Aufgaben im Zusammenhang mit dem Anwendungsstart auszuführen. Das folgende Codebeispiel zeigt die MainActivity -Klasse in der Beispielanwendung:

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;
    }
    ...
}

Die Methode OnCreate führt die folgenden Aufgaben aus:

  • Xamarin.Forms wird durch Aufrufen der Forms.Init -Methode initialisiert.
  • Ein neues Xamarin.Forms.Application ist -Objekt wird erstellt, und sein Ressourcenverzeichnis auf Anwendungsebene wird auf ein ResourceDictionary festgelegt, das in XAML definiert ist.
  • Im Feld wird ein Verweis auf die MainActivitystaticInstance -Klasse gespeichert. Dadurch wird ein Mechanismus bereitgestellt, mit dem andere Klassen methoden aufrufen können, die in der MainActivity -Klasse definiert sind.
  • Der Activity Inhalt wird aus einer Layoutressource festgelegt. In der Beispielanwendung besteht das Layout aus einem LinearLayout , das ein Toolbarenthält, und ein , FrameLayout das als Fragmentcontainer fungiert.
  • Wird Toolbar abgerufen und als Aktionsleiste für Activityfestgelegt, und der Titel der Aktionsleiste ist festgelegt.
  • Die FolderPath -Eigenschaft wird in einen Pfad auf dem Gerät initialisiert, in dem Notizdaten gespeichert werden.
  • Es NotesPage wird ein -Objekt erstellt, bei dem es sich um eine Xamarin.FormsContentPagein XAML definierte abgeleitete Seite handelt, und das übergeordnete Element wird auf das zuvor erstellte Xamarin.Forms.Application Objekt festgelegt.
  • Das NotesPage -Objekt wird mithilfe der CreateSupportFragment Erweiterungsmethode in ein Fragment konvertiert.
  • Die SupportFragmentManager -Klasse erstellt und committet eine Transaktion, die die FrameLayout instance durch den Fragment für die NotesPage -Klasse ersetzt.
  • Die Parent -Eigenschaft des NotesPage -Objekts wird auf nullfestgelegt, um einen Speicherverlust zu verhindern.

Weitere Informationen zu Fragmenten finden Sie unter Fragmente.

Nachdem die OnCreate Methode ausgeführt wurde, wird die in der Xamarin.FormsNotesPage -Klasse definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

zeigt einen Notizenbildschirm auf einem mobilen Gerät mit einem blauen Banner und farbigem Notiztext.

Wichtig

Alle ContentPageabgeleiteten Seiten können Ressourcen nutzen, die in der Anwendungsebene ResourceDictionarydefiniert sind, vorausgesetzt, dass die Parent -Eigenschaft der Seite auf das Application -Objekt festgelegt ist.

Wenn Sie mit der Benutzeroberfläche interagieren, z. B. durch Tippen auf +Button, wird der folgende Ereignishandler in der NotesPage CodeBehind-Ausführung ausgeführt:

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

Das staticMainActivity.Instance -Feld ermöglicht das Aufrufen der MainActivity.NavigateToNoteEntryPage -Methode, was im folgenden Codebeispiel gezeigt wird:

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

Die NavigateToNoteEntryPage -Methode konvertiert die Xamarin.FormsContentPage-abgeleitete Seite mit der CreateSupportFragment Erweiterungsmethode in eine Fragment und fügt dem Fragmentbackstapel hinzuFragment. Daher wird die in Xamarin.FormsNoteEntryPage definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

Screenshot zeigt einen Hinweiseintrag auf einem mobilen Gerät mit einem blauen Banner.

Wenn der NoteEntryPage angezeigt wird, wird durch Tippen auf den Zurück-Pfeil der für aus NoteEntryPageFragment dem Fragmentbackstapel eingeblendet, und der Benutzer wird zum Fragment -Element für die NotesPage -Klasse zurückgegeben.

Aktivieren der Rücknavigationsunterstützung

Die SupportFragmentManager -Klasse verfügt über ein BackStackChanged Ereignis, das immer dann ausgelöst wird, wenn sich der Inhalt des Fragmentbackstapels ändert. Die OnCreate -Methode in der MainActivity -Klasse enthält einen anonymen Ereignishandler für dieses Ereignis:

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

Dieser Ereignishandler zeigt eine Zurück-Schaltfläche auf der Aktionsleiste an, vorausgesetzt, es gibt eine oder Fragment mehrere Instanzen im Fragmentbackstapel. Die Antwort auf das Tippen auf die Zurück-Schaltfläche wird von der OnOptionsItemSelected Überschreibung behandelt:

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

Die OnOptionsItemSelected Außerkraftsetzung wird immer dann aufgerufen, wenn ein Element im Optionsmenü ausgewählt wird. Diese Implementierung füllt das aktuelle Fragment aus dem Zurück-Fragmentstapel ein, vorausgesetzt, dass die Schaltfläche Zurück ausgewählt wurde und eine oder Fragment mehrere Instanzen im Fragmentbackstapel vorhanden sind.

Mehrere Aktivitäten

Wenn eine Anwendung aus mehreren Aktivitäten besteht, ContentPagekönnen abgeleitete Seiten in jede der Aktivitäten eingebettet werden. In diesem Szenario muss die Forms.Init -Methode nur in der OnCreate Überschreibung der ersten Activity aufgerufen werden, die eine Xamarin.FormsContentPageeinbettet. Dies hat jedoch folgende Auswirkungen:

  • Der Wert von Xamarin.Forms.Color.Accent wird von der übernommen, die Activity die Forms.Init -Methode aufgerufen hat.
  • Der Wert von Xamarin.Forms.Application.Current wird dem zugeordnet, das Activity die Forms.Init -Methode aufgerufen hat.

Datei auswählen

Beim Einbetten einer ContentPage-abgeleiteten Seite, die eine WebView verwendet, die eine HTML-Schaltfläche "Datei auswählen" unterstützen muss, muss die ActivityOnActivityResult -Methode überschrieben werden:

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

UWP

In UWP ist die native App Klasse in der Regel der Ort, um Aufgaben im Zusammenhang mit dem Anwendungsstart auszuführen. Xamarin.Forms wird normalerweise in Xamarin.Forms UWP-Anwendungen in der OnLaunched Überschreibung in der nativen App Klasse initialisiert, um das LaunchActivatedEventArgs Argument an die Forms.Init -Methode zu übergeben. Aus diesem Grund können native UWP-Anwendungen, die eine Xamarin.FormsContentPageabgeleitete Seite nutzen, die Methode am einfachsten von der Forms.InitApp.OnLaunched -Methode aufrufen:

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

    // ...
}

Darüber hinaus kann die OnLaunched -Methode auch ein beliebiges Ressourcenwörterbuch auf Anwendungsebene erstellen, das von der Anwendung benötigt wird.

Standardmäßig startet die native App Klasse die MainPage -Klasse als erste Seite der Anwendung. Das folgende Codebeispiel zeigt die MainPage -Klasse in der Beispielanwendung:

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;    
    }
    // ...
}

Der MainPage Konstruktor führt die folgenden Aufgaben aus:

  • Die Zwischenspeicherung ist für die Seite aktiviert, sodass kein neues MainPage erstellt wird, wenn ein Benutzer zurück zur Seite navigiert.
  • Im Feld wird ein Verweis auf die MainPagestaticInstance -Klasse gespeichert. Dadurch wird ein Mechanismus für andere Klassen bereitgestellt, um in der MainPage -Klasse definierte Methoden aufzurufen.
  • Die FolderPath -Eigenschaft wird in einen Pfad auf dem Gerät initialisiert, auf dem Notizdaten gespeichert werden.
  • Es NotesPage wird ein Objekt erstellt, bei dem es sich um eine Xamarin.FormsContentPagein XAML definierte abgeleitete Seite handelt, und das übergeordnete Objekt wird auf das zuvor erstellte Xamarin.Forms.Application Objekt festgelegt.
  • Das NotesPage Objekt wird mithilfe der CreateFrameworkElement Erweiterungsmethode in ein FrameworkElement konvertiert und dann als Inhalt der MainPage Klasse festgelegt.
  • Die Parent -Eigenschaft des NotesPage -Objekts ist auf nullfestgelegt, um einen Speicherverlust zu verhindern.

Nachdem der MainPage Konstruktor ausgeführt wurde, wird die in der Xamarin.FormsNotesPage -Klasse definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

: Seite

Wichtig

Alle ContentPageabgeleiteten Seiten können Ressourcen nutzen, die in der Anwendungsebene ResourceDictionarydefiniert sind, vorausgesetzt, die Parent Eigenschaft der Seite ist auf das Application -Objekt festgelegt.

Wenn Sie mit der Benutzeroberfläche interagieren, z. B. durch Tippen auf +Button, wird der folgende Ereignishandler in der NotesPage CodeBehind-Ausführung ausgeführt:

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

Das staticMainPage.Instance Feld ermöglicht das Aufrufen der MainPage.NavigateToNoteEntryPage -Methode, was im folgenden Codebeispiel gezeigt wird:

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

Die Navigation in UWP wird in der Regel mit der Frame.Navigate -Methode ausgeführt, die ein Page Argument akzeptiert. Xamarin.Formsdefiniert eine Frame.Navigate Erweiterungsmethode, die eine ContentPageabgeleitete Seite instance. Wenn die NavigateToNoteEntryPage Methode ausgeführt wird, wird daher die in Xamarin.FormsNoteEntryPage definierte Benutzeroberfläche angezeigt, wie im folgenden Screenshot gezeigt:

: Seite

Wenn der NoteEntryPage angezeigt wird, wird durch Tippen auf den Zurück-Pfeil das für den NoteEntryPageFrameworkElement aus dem In-App-Back-Stapel angezeigt, wodurch der Benutzer zu der FrameworkElement für die NotesPage -Klasse zurückgibt.

Aktivieren der Unterstützung für Die Seitengrößesänderung

Wenn die Größe des UWP-Anwendungsfensters geändert wird, sollte auch die Größe des Xamarin.Forms Inhalts geändert werden. Dies wird durch Registrieren eines Ereignishandlers für das Loaded Ereignis im MainPage Konstruktor erreicht:

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

Das Loaded Ereignis wird ausgelöst, wenn die Seite angelegt, gerendert und für die Interaktion bereit ist, und führt die OnMainPageLoaded -Methode als Antwort aus:

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

Die OnMainPageLoaded -Methode registriert einen anonymen Ereignishandler für das -Ereignis, das Frame.SizeChanged ausgelöst wird, wenn sich entweder die ActualHeight -Eigenschaft oder die ActualWidth -Eigenschaft für ändern Frame. Als Reaktion wird die Größe des Xamarin.Forms Inhalts für die aktive Seite geändert, indem die Layout -Methode aufgerufen wird.

Aktivieren der Rücknavigationsunterstützung

Auf UWP müssen Anwendungen die Zurücknavigation für alle Hardware- und Softwarerückschaltflächen für verschiedene Geräteformfaktoren aktivieren. Dies kann erreicht werden, indem Sie einen Ereignishandler für das BackRequested Ereignis registrieren, das im MainPage Konstruktor ausgeführt werden kann:

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

Wenn die Anwendung gestartet wird, ruft die GetForCurrentView -Methode das SystemNavigationManager der aktuellen Ansicht zugeordnete Objekt ab und registriert dann einen Ereignishandler für das BackRequested Ereignis. Die Anwendung empfängt dieses Ereignis nur, wenn es sich um die Vordergrundanwendung handelt, und ruft als Antwort den OnBackRequested Ereignishandler auf:

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

Der OnBackRequested Ereignishandler ruft die GoBack -Methode im Stammframe der Anwendung auf und legt die BackRequestedEventArgs.Handled -Eigenschaft auf fest, um true das Ereignis als behandelt zu markieren. Wenn das Ereignis nicht als behandelt markiert wird, kann dies dazu führen, dass das Ereignis ignoriert wird.

Die Anwendung wählt aus, ob eine Zurück-Schaltfläche auf der Titelleiste angezeigt werden soll. Dies wird erreicht, indem die AppViewBackButtonVisibility -Eigenschaft auf einen der AppViewBackButtonVisibility Enumerationswerte in der App -Klasse festgelegt wird:

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

Der OnNavigated Ereignishandler, der als Reaktion auf das Auslösen des Navigated Ereignisses ausgeführt wird, aktualisiert die Sichtbarkeit der Schaltfläche "Zurück" in der Titelleiste, wenn die Seitennavigation erfolgt. Dadurch wird sichergestellt, dass die Schaltfläche "Zurück" in der Titelleiste sichtbar ist, wenn der In-App-Back-Stapel nicht leer ist, oder aus der Titelleiste entfernt wird, wenn der In-App-Back-Stapel leer ist.

Weitere Informationen zur Unterstützung der Backnavigation in UWP finden Sie unter Navigationsverlauf und Rückwärtsnavigation für UWP-Apps.