Gestire la sospensione dell'app

API importanti

• Suspending

Informazioni su come salvare i dati importanti dell'applicazione quando viene sospesa dal sistema. Nell'esempio viene registrato un gestore eventi per l'evento Suspending e viene salvata una stringa in un file.

Registrare il gestore eventi di sospensione

Registrare per gestire l'evento Suspending, che indica che l'app deve salvare i dati dell'applicazione prima che il sistema la sospenda.

using System;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.UI.Xaml;

partial class MainPage
{
   public MainPage()
   {
      InitializeComponent();
      Application.Current.Suspending += new SuspendingEventHandler(App_Suspending);
   }
}

Public NotInheritable Class MainPage

   Public Sub New()
      InitializeComponent()
      AddHandler Application.Current.Suspending, AddressOf App_Suspending
   End Sub
   
End Class

MainPage::MainPage()
{
    InitializeComponent();
    Windows::UI::Xaml::Application::Current().Suspending({ this, &MainPage::App_Suspending });
}

using namespace Windows::ApplicationModel;
using namespace Windows::ApplicationModel::Activation;
using namespace Windows::Foundation;
using namespace Windows::UI::Xaml;
using namespace AppName;

MainPage::MainPage()
{
   InitializeComponent();
   Application::Current->Suspending +=
       ref new SuspendingEventHandler(this, &MainPage::App_Suspending);
}

Salvare i dati dell'applicazione prima della sospensione

Quando l'app gestisce l'evento Suspending, ha la possibilità di salvare i dati importanti dell'applicazione nella funzione del gestore. L'app deve usare l'API di archiviazione LocalSettings per salvare in modo sincrono i dati delle applicazioni semplici.

partial class MainPage
{
    async void App_Suspending(
        Object sender,
        Windows.ApplicationModel.SuspendingEventArgs e)
    {
        // TODO: This is the time to save app data in case the process is terminated.
    }
}

Public NonInheritable Class MainPage

    Private Sub App_Suspending(
        sender As Object,
        e As Windows.ApplicationModel.SuspendingEventArgs) Handles OnSuspendEvent.Suspending

        ' TODO: This is the time to save app data in case the process is terminated.
    End Sub

End Class

void MainPage::App_Suspending(
    Windows::Foundation::IInspectable const& /* sender */,
    Windows::ApplicationModel::SuspendingEventArgs const& /* e */)
{
    // TODO: This is the time to save app data in case the process is terminated.
}

void MainPage::App_Suspending(Object^ sender, SuspendingEventArgs^ e)
{
    // TODO: This is the time to save app data in case the process is terminated.
}

Rilasciare risorse

Si devono liberare risorse e handle di file esclusivi in modo che altre app possano accedervi mentre l'app è sospesa. Esempi di risorse esclusive includono fotocamere, dispositivi I/O, dispositivi esterni e risorse di rete. Il rilascio esplicito di risorse esclusive e handle di file consente di garantire che altre app possano accedervi durante la sospensione dell'app. Quando l'app viene ripresa, deve riacquisire le risorse esclusive e gli handle di file.

Osservazioni:

Il sistema sospende l'app ogni volta che l'utente passa a un'altra app o alla schermata desktop o Start. Il sistema riprende l'app ogni qualvolta l'utente torna ad essa. Quando il sistema riprende l'app, il contenuto delle variabili e delle strutture dati corrisponde a quello precedente alla sospensione dell'app da parte del sistema. Il sistema ripristina l'app esattamente da dove era stata interrotta, in modo che appaia all'utente come se fosse in esecuzione in background.

Il sistema tenta di mantenere l'app e i relativi dati in memoria mentre è sospeso. Tuttavia, se il sistema non dispone delle risorse per mantenere l'app in memoria, il sistema terminerà l'app. Quando l'utente torna a un'app sospesa che è stata terminata, il sistema invia un evento Activated e deve ripristinare i dati dell'applicazione nel metodo OnLaunched.

Il sistema non invia una notifica a un'app quando viene terminata, quindi l'app deve salvare i dati dell'applicazione e rilasciare risorse e handle di file esclusivi quando viene sospesa e ripristinarli quando l'app viene attivata dopo la chiusura.

Se si effettua una chiamata asincrona all'interno del gestore, il controllo ritorna immediatamente da tale chiamata asincrona. Ciò significa che l'esecuzione può quindi far restituire dal gestore eventi e l'app passerà allo stato successivo anche se la chiamata asincrona non è ancora stata completata. Utilizzare il metodo GetDeferral sull'oggetto EnteredBackgroundEventArgs che è passato all'handler dell'evento per ritardare la sospensione fino a dopo il richiamo del metodo Complete sull'oggetto Windows.Foundation.Deferral restituito.

Un differimento non aumenta la quantità di tempo necessario per eseguire il codice prima che l'app venga terminata. Ritarda solo la terminazione fino a quando non viene chiamato il metodo Complete, o la deadline è superata-quale dei due eventi si verifica prima. Per estendere il tempo nello stato di sospensione, usare ExtendedExecutionSession

Una nota sul debug con Visual Studio: Visual Studio impedisce a Windows di sospendere un'app collegata al debugger. Ciò consente all'utente di visualizzare l'interfaccia utente di debug di Visual Studio mentre l'app è in esecuzione. Quando si esegue il debug di un'app, è possibile inviare un evento di sospensione usando Visual Studio. Verificare che la arra degli strumenti Posizione di debug sia visualizzata, quindi fare clic sull'icona Sospendi .

Argomenti correlati

• Ciclo di vita dell'app
• Gestire l'attivazione dell'app
• Gestire la ripresa dell'app
• Linee guida UX per avvio, sospensione e ripresa
• Esecuzione estesa