Condividi tramite

Xamarin.Forms nei progetti nativi di Xamarin

  • Articolo

In genere, un'applicazione Xamarin.Forms include una o più pagine che derivano da ContentPagee queste pagine vengono condivise da tutte le piattaforme in un progetto di libreria .NET Standard o progetto condiviso. Tuttavia, Native Forms consente l'aggiunta ContentPagedi pagine derivate direttamente alle applicazioni Xamarin.iOS, Xamarin.Android e UWP native. Rispetto al fatto che il progetto nativo utilizza ContentPagepagine derivate da un progetto di libreria .NET Standard o progetto condiviso, il vantaggio di aggiungere pagine direttamente ai progetti nativi è che le pagine possono essere estese con visualizzazioni native. Le visualizzazioni native possono quindi essere denominate in XAML con x:Name e a cui viene fatto riferimento dal code-behind. Per altre informazioni sulle viste native, vedere Viste native.

Il processo per l'utilizzo di una Xamarin.FormsContentPagepagina derivata da -in un progetto nativo è il seguente:

  1. Aggiungere il Xamarin.Forms pacchetto NuGet al progetto nativo.
  2. Aggiungere la ContentPagepagina derivata da e tutte le dipendenze al progetto nativo.
  3. Chiamare il metodo Forms.Init .
  4. Creare un'istanza della ContentPagepagina derivata da e convertirla nel tipo nativo appropriato usando uno dei metodi di estensione seguenti: CreateViewController per iOS, CreateSupportFragment per Android o CreateFrameworkElement per UWP.
  5. Passare alla rappresentazione del tipo nativo della ContentPagepagina derivata tramite l'API di spostamento nativa.

Xamarin.Forms deve essere inizializzato chiamando il Forms.Init metodo prima che un progetto nativo possa costruire una ContentPagepagina derivata da . La scelta di quando eseguire questa operazione dipende principalmente dal momento in cui è più conveniente nel flusso dell'applicazione, che può essere eseguita all'avvio dell'applicazione o subito prima che venga costruita la ContentPagepagina derivata da . In questo articolo e nelle applicazioni di esempio abbinate viene chiamato il Forms.Init metodo all'avvio dell'applicazione.

Nota

La soluzione dell'applicazione di esempio NativeForms non contiene progetti Xamarin.Forms . È invece costituito da un progetto Xamarin.iOS, un progetto Xamarin.Android e un progetto UWP. Ogni progetto è un progetto nativo che usa moduli nativi per utilizzare ContentPagepagine derivate da . Tuttavia, non c'è motivo per cui i progetti nativi non potevano utilizzare ContentPagepagine derivate da un progetto di libreria .NET Standard o un progetto condiviso.

Quando si usano moduli nativi, Xamarin.Forms tutte le funzionalità come DependencyService, MessagingCentere il motore di data binding funzionano ancora. Tuttavia, lo spostamento tra le pagine deve essere eseguito usando l'API di spostamento nativa.

iOS

In iOS, l'override FinishedLaunching nella AppDelegate classe è in genere la posizione in cui eseguire attività correlate all'avvio dell'applicazione. Viene chiamato dopo l'avvio dell'applicazione ed è in genere sottoposto a override per configurare la finestra principale e il controller di visualizzazione. L'esempio di codice seguente illustra la AppDelegate classe nell'applicazione di esempio:

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

Il metodo FinishedLaunching esegue le attività seguenti:

  • Xamarin.Forms viene inizializzato chiamando il Forms.Init metodo .
  • Viene creato un nuovo Xamarin.Forms.Application oggetto e il relativo dizionario risorse a livello di applicazione è impostato su un ResourceDictionary oggetto definito in XAML.
  • Un riferimento alla AppDelegate classe viene archiviato nel static Instance campo . Si tratta di fornire un meccanismo per altre classi per chiamare i metodi definiti nella AppDelegate classe .
  • Viene UIWindowcreato il contenitore principale per le visualizzazioni nelle applicazioni iOS native.
  • La FolderPath proprietà viene inizializzata in un percorso nel dispositivo in cui verranno archiviati i dati delle note.
  • Viene creato un NotesPage oggetto, ovvero una Xamarin.FormsContentPagepagina derivata da -definita in XAML e il relativo elemento padre viene impostato sull'oggetto creato Xamarin.Forms.Application in precedenza.
  • L'oggetto NotesPage viene convertito in un UIViewController oggetto utilizzando il CreateViewController metodo di estensione.
  • La Title proprietà di UIViewController è impostata, che verrà visualizzata nell'oggetto UINavigationBar.
  • Viene creato un AppNavigationController oggetto per la gestione della navigazione gerarchica. Si tratta di una classe controller di spostamento personalizzata, che deriva da UINavigationController. L'oggetto AppNavigationController gestisce uno stack di controller di visualizzazione e l'oggetto UIViewController passato al costruttore verrà presentato inizialmente quando AppNavigationController viene caricato .
  • L'oggetto AppNavigationController viene impostato come primo livello UIViewController per UIWindowe UIWindow viene impostato come finestra chiave per l'applicazione e viene reso visibile.
  • La Parent proprietà dell'oggetto NotesPage è impostata su nullper evitare una perdita di memoria.

Dopo l'esecuzione del FinishedLaunching metodo, verrà visualizzata l'interfaccia utente definita nella Xamarin.FormsNotesPage classe , come illustrato nello screenshot seguente:

Screenshot che mostra una schermata Note in un dispositivo mobile.

Importante

Tutte le ContentPagepagine derivate da possono utilizzare risorse definite a livello ResourceDictionarydi applicazione, a condizione che la Parent proprietà della pagina sia impostata sull'oggetto Application .

L'interazione con l'interfaccia utente, ad esempio toccando su + Button, comporterà l'esecuzione del NotesPage gestore eventi seguente nel code-behind:

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

Il static AppDelegate.Instance campo consente di richiamare il AppDelegate.NavigateToNoteEntryPage metodo , illustrato nell'esempio di codice seguente:

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

Il NavigateToNoteEntryPage metodo converte la Xamarin.FormsContentPagepagina derivata da in un UIViewController oggetto con il CreateViewController metodo di estensione e imposta la Title proprietà dell'oggetto UIViewController. l'oggetto UIViewController viene quindi inserito AppNavigationController dal PushViewController metodo . Pertanto, l'interfaccia utente definita nella Xamarin.FormsNoteEntryPage classe verrà visualizzata, come illustrato nello screenshot seguente:

Screenshot che mostra una voce nota in un dispositivo mobile.

NoteEntryPage Quando viene visualizzato , lo spostamento indietro aprirà per UIViewController la NoteEntryPage classe da AppNavigationController, restituendo l'utente a UIViewController per la NotesPage classe . Tuttavia, l'estrazione di un UIViewController oggetto dallo stack di spostamento nativo iOS non elimina automaticamente l'oggetto UIViewController associato e .Page Pertanto, la classe esegue l'override AppNavigationController del PopViewController metodo per eliminare i controller di visualizzazione sullo spostamento indietro:

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

L'override PopViewController chiama il Dispose metodo sull'oggetto UIViewController estratto dallo stack di navigazione nativo iOS. Se non si esegue questa operazione, l'oggetto UIViewController collegato e sarà orfano Page .

Importante

Gli oggetti orfani non possono essere sottoposto a Garbage Collection e quindi comportano una perdita di memoria.

Android

In Android, l'override OnCreate nella MainActivity classe è in genere la posizione in cui eseguire le attività correlate all'avvio dell'applicazione. L'esempio di codice seguente illustra la MainActivity classe nell'applicazione di esempio:

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

Il metodo OnCreate esegue le attività seguenti:

  • Xamarin.Forms viene inizializzato chiamando il Forms.Init metodo .
  • Viene creato un nuovo Xamarin.Forms.Application oggetto e il relativo dizionario risorse a livello di applicazione è impostato su un ResourceDictionary oggetto definito in XAML.
  • Un riferimento alla MainActivity classe viene archiviato nel static Instance campo . Si tratta di fornire un meccanismo per altre classi per chiamare i metodi definiti nella MainActivity classe .
  • Il Activity contenuto viene impostato da una risorsa di layout. Nell'applicazione di esempio il layout è costituito da un LinearLayout che contiene un Toolbare un oggetto FrameLayout da usare come contenitore di frammenti.
  • Viene Toolbar recuperato e impostato come barra delle azioni per Activitye il titolo della barra delle azioni è impostato.
  • La FolderPath proprietà viene inizializzata in un percorso nel dispositivo in cui verranno archiviati i dati delle note.
  • Viene creato un NotesPage oggetto, ovvero una Xamarin.FormsContentPagepagina derivata da -definita in XAML e il relativo elemento padre viene impostato sull'oggetto creato Xamarin.Forms.Application in precedenza.
  • L'oggetto NotesPage viene convertito in un Fragment oggetto utilizzando il CreateSupportFragment metodo di estensione.
  • La SupportFragmentManager classe crea ed esegue il commit di una transazione che sostituisce l'istanza FrameLayout con per Fragment la NotesPage classe .
  • La Parent proprietà dell'oggetto NotesPage è impostata su nullper evitare una perdita di memoria.

Per altre informazioni sui frammenti, vedere Frammenti.

Dopo l'esecuzione del OnCreate metodo, verrà visualizzata l'interfaccia utente definita nella Xamarin.FormsNotesPage classe , come illustrato nello screenshot seguente:

Screenshot che mostra una schermata Note in un dispositivo mobile con un banner blu e un testo di nota colorato.

Importante

Tutte le ContentPagepagine derivate da possono utilizzare risorse definite a livello ResourceDictionarydi applicazione, a condizione che la Parent proprietà della pagina sia impostata sull'oggetto Application .

L'interazione con l'interfaccia utente, ad esempio toccando su + Button, comporterà l'esecuzione del NotesPage gestore eventi seguente nel code-behind:

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

Il static MainActivity.Instance campo consente di richiamare il MainActivity.NavigateToNoteEntryPage metodo , illustrato nell'esempio di codice seguente:

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

Il NavigateToNoteEntryPage metodo converte la Xamarin.FormsContentPagepagina derivata da in un Fragment oggetto con il CreateSupportFragment metodo di estensione e aggiunge l'oggetto Fragment allo stack back del frammento. Di conseguenza, l'interfaccia utente definita in Xamarin.FormsNoteEntryPage verrà visualizzata, come illustrato nello screenshot seguente:

Screenshot che mostra una voce nota in un dispositivo mobile con un banner blu.

Quando l'oggetto NoteEntryPage viene visualizzato, toccando la freccia indietro si aprirà Fragment per l'oggetto NoteEntryPage dallo stack indietro del frammento, restituendo l'utente all'oggetto Fragment per la NotesPage classe .

Abilitare il supporto per lo spostamento indietro

La SupportFragmentManager classe ha un BackStackChanged evento che viene generato ogni volta che cambia il contenuto dello stack back del frammento. Il OnCreate metodo nella MainActivity classe contiene un gestore eventi anonimo per questo evento:

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

Questo gestore eventi visualizza un pulsante Indietro sulla barra delle azioni a condizione che siano presenti una o più Fragment istanze nello stack back del frammento. La risposta a toccare il pulsante Indietro viene gestita dall'override OnOptionsItemSelected :

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

L'override OnOptionsItemSelected viene chiamato ogni volta che viene selezionata una voce nel menu delle opzioni. Questa implementazione popa il frammento corrente dallo stack back del frammento, a condizione che il pulsante Indietro sia stato selezionato e che siano presenti una o più Fragment istanze nello stack back del frammento.

Più attività

Quando un'applicazione è composta da più attività, ContentPagele pagine derivate da possono essere incorporate in ognuna delle attività. In questo scenario, il Forms.Init metodo deve essere chiamato solo nell'override OnCreate del primo Activity oggetto che incorpora un oggetto Xamarin.FormsContentPage. Tuttavia, questo ha l'impatto seguente:

  • Il valore di Xamarin.Forms.Color.Accent verrà ricavato dall'oggetto Activity che ha chiamato il Forms.Init metodo .
  • Il valore di Xamarin.Forms.Application.Current verrà associato all'oggetto Activity che ha chiamato il Forms.Init metodo .

Scegli un file

Quando si incorpora una ContentPagepagina derivata da che usa un oggetto WebView che deve supportare un pulsante HTML "Choose File", è necessario eseguire l'override Activity del OnActivityResult metodo :

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

UWP

Nella piattaforma UWP la classe nativa App è in genere la posizione in cui eseguire attività correlate all'avvio dell'applicazione. Xamarin.Forms viene in genere inizializzato, nelle Xamarin.Forms applicazioni UWP, nell'override OnLaunched nella classe nativa App , per passare l'argomento LaunchActivatedEventArgs al Forms.Init metodo . Per questo motivo, le applicazioni UWP native che usano una Xamarin.FormsContentPagepagina derivata da possono chiamare più facilmente il Forms.Init metodo dal App.OnLaunched metodo :

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

    // ...
}

Inoltre, il OnLaunched metodo può anche creare qualsiasi dizionario risorse a livello di applicazione richiesto dall'applicazione.

Per impostazione predefinita, la classe nativa App avvia la MainPage classe come prima pagina dell'applicazione. L'esempio di codice seguente illustra la MainPage classe nell'applicazione di esempio:

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

Il MainPage costruttore esegue le attività seguenti:

  • La memorizzazione nella cache è abilitata per la pagina, in modo che un nuovo MainPage non venga costruito quando un utente torna alla pagina.
  • Un riferimento alla MainPage classe viene archiviato nel static Instance campo . Si tratta di fornire un meccanismo per altre classi per chiamare i metodi definiti nella MainPage classe .
  • La FolderPath proprietà viene inizializzata in un percorso nel dispositivo in cui verranno archiviati i dati delle note.
  • Viene creato un NotesPage oggetto, ovvero una Xamarin.FormsContentPagepagina derivata da -definita in XAML e il relativo elemento padre viene impostato sull'oggetto creato Xamarin.Forms.Application in precedenza.
  • L'oggetto NotesPage viene convertito in un FrameworkElement oggetto utilizzando il CreateFrameworkElement metodo di estensione e quindi impostato come contenuto della MainPage classe .
  • La Parent proprietà dell'oggetto NotesPage è impostata su nullper evitare una perdita di memoria.

Dopo l'esecuzione del MainPage costruttore, verrà visualizzata l'interfaccia utente definita nella Xamarin.FormsNotesPage classe , come illustrato nello screenshot seguente:

Screenshot che mostra una pagina Note con note e data/ora.

Importante

Tutte le ContentPagepagine derivate da possono utilizzare risorse definite a livello ResourceDictionarydi applicazione, a condizione che la Parent proprietà della pagina sia impostata sull'oggetto Application .

L'interazione con l'interfaccia utente, ad esempio toccando su + Button, comporterà l'esecuzione del NotesPage gestore eventi seguente nel code-behind:

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

Il static MainPage.Instance campo consente di richiamare il MainPage.NavigateToNoteEntryPage metodo , illustrato nell'esempio di codice seguente:

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

Lo spostamento nella piattaforma UWP viene in genere eseguito con il Frame.Navigate metodo , che accetta un Page argomento. Xamarin.Forms definisce un metodo di Frame.Navigate estensione che accetta un'istanza ContentPagedi pagina derivata da . Pertanto, quando il NavigateToNoteEntryPage metodo viene eseguito, verrà visualizzata l'interfaccia utente definita in Xamarin.FormsNoteEntryPage , come illustrato nello screenshot seguente:

Screenshot che mostra una pagina Note con una casella di testo con una nota immessa.

Quando l'oggetto NoteEntryPage viene visualizzato, toccando la freccia indietro si aprirà FrameworkElement per l'oggetto NoteEntryPage dallo stack back in-app, restituendo l'utente all'oggetto FrameworkElement per la NotesPage classe .

Abilitare il supporto per il ridimensionamento delle pagine

Quando la finestra dell'applicazione UWP viene ridimensionata, anche il Xamarin.Forms contenuto deve essere ridimensionato. Questa operazione viene eseguita registrando un gestore eventi per l'evento Loaded , nel MainPage costruttore :

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

L'evento Loaded viene generato quando la pagina viene disposta, sottoposta a rendering e pronta per l'interazione ed esegue il OnMainPageLoaded metodo in risposta:

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

Il OnMainPageLoaded metodo registra un gestore eventi anonimo per l'evento Frame.SizeChanged , che viene generato quando le ActualHeight proprietà o ActualWidth cambiano in Frame. In risposta, il Xamarin.Forms contenuto della pagina attiva viene ridimensionato chiamando il Layout metodo .

Abilitare il supporto per lo spostamento indietro

Nella piattaforma UWP, le applicazioni devono abilitare lo spostamento indietro per tutti i pulsanti indietro hardware e software, in diversi fattori di forma del dispositivo. A tale scopo, è possibile registrare un gestore eventi per l'evento BackRequested , che può essere eseguito nel MainPage costruttore:

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

Quando l'applicazione viene avviata, il GetForCurrentView metodo recupera l'oggetto SystemNavigationManager associato alla visualizzazione corrente, quindi registra un gestore eventi per l'evento BackRequested . L'applicazione riceve questo evento solo se è l'applicazione in primo piano e in risposta chiama il OnBackRequested gestore eventi:

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

Il OnBackRequested gestore eventi chiama il GoBack metodo nel frame radice dell'applicazione e imposta la BackRequestedEventArgs.Handled proprietà su per true contrassegnare l'evento come gestito. Se non si contrassegna l'evento come gestito, l'evento potrebbe essere ignorato.

L'applicazione sceglie se visualizzare un pulsante Indietro sulla barra del titolo. Questa operazione viene ottenuta impostando la AppViewBackButtonVisibility proprietà su uno dei AppViewBackButtonVisibility valori di enumerazione, nella App classe :

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

Il OnNavigated gestore eventi, che viene eseguito in risposta alla generazione dell'evento Navigated , aggiorna la visibilità del pulsante Indietro della barra del titolo quando si verifica lo spostamento nella pagina. In questo modo si garantisce che il pulsante Indietro della barra del titolo sia visibile se lo stack back in-app non è vuoto o rimosso dalla barra del titolo se lo stack back in-app è vuoto.

Per altre informazioni sul supporto dello spostamento indietro su UWP, vedi Cronologia di spostamento e spostamento indietro per le app UWP.