Gestire la sospensione dell'appHandle app suspend

API importantiImportant APIs

Scopri come salvare i dati importanti dell'applicazione quando viene sospesa dal sistema.Learn how to save important application data when the system suspends your app. L'esempio registra un gestore per l'evento Suspending e salva una stringa in un file.The example registers an event handler for the Suspending event and saves a string to a file.

Registrare il gestore eventi di sospensioneRegister the suspending event handler

Eseguire la registrazione per gestire l'evento di sospensione , che indica che l'app deve salvare i dati dell'applicazione prima che il sistema lo sospenda.Register to handle the Suspending event, which indicates that your app should save its application data before the system suspends it.

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 sospensioneSave application data before suspension

Quando la tua app gestisce l’evento Suspending, ha la possibilità di salvare i dati importanti tramite la funzione del gestore.When your app handles the Suspending event, it has the opportunity to save its important application data in the handler function. L'app deve usare l'API di archiviazione LocalSettings per salvare i dati semplici dell'applicazione in modo sincrono.The app should use the LocalSettings storage API to save simple application data synchronously.

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 risorseRelease resources

Devi provvedere al rilascio esplicito delle risorse e degli handle di file esclusivi in modo da garantire ad altre app di potervi accedere quando la tua app è sospesa.You should release exclusive resources and file handles so that other apps can access them while your app is suspended. Esempi di risorse esclusive sono le fotocamere, i dispositivi di I/O, i dispositivi esterni e le risorse di rete.Examples of exclusive resources include cameras, I/O devices, external devices, and network resources. Il rilascio esplicito di risorse esclusive e di handle di file garantisce ad altre app di potervi accedere quando la tua app è sospesa.Explicitly releasing exclusive resources and file handles helps to ensure that other apps can access them while your app is suspended. Quando l'app viene ripresa, deve riacquisire le risorse esclusive e gli handle di file.When the app is resumed, it should reacquire its exclusive resources and file handles.

CommentiRemarks

Il sistema sospende l'esecuzione dell'app tutte le volte che l'utente passa a un'altra app, al desktop o alla schermata Start.The system suspends your app whenever the user switches to another app or to the desktop or Start screen. Il sistema riprende l'esecuzione dell'app ogni volta che l'utente vi ritorna.The system resumes your app whenever the user switches back to it. Quando il sistema riprende l'app, il contenuto delle variabili e delle strutture di dati è lo stesso esistente prima della sospensione dell'app.When the system resumes your app, the content of your variables and data structures is the same as it was before the system suspended the app. Il sistema riprende l'esecuzione dell'app esattamente dal punto in cui era stata interrotta, dando all'utente l'impressione che venisse eseguita in background.The system restores the app exactly where it left off, so that it appears to the user as if it's been running in the background.

Durante il periodo della sospensione, il sistema cerca di mantenere l'app e i suoi dati in memoria.The system attempts to keep your app and its data in memory while it's suspended. Se però non dispone delle risorse necessarie per mantenerla in memoria, chiuderà la tua app.However, if the system does not have the resources to keep your app in memory, the system will terminate your app. Quando l'utente torna a un'app sospesa che è stata terminata, il sistema invia un evento attivato e deve ripristinare i dati dell'applicazione nel metodo OnLaunched .When the user switches back to a suspended app that has been terminated, the system sends an Activated event and should restore its application data in its OnLaunched method.

Il sistema non notifica all'app che verrà chiusa, pertanto l'app deve salvare i relativi dati dell'applicazione e rilasciare risorse esclusive e handle di file quando viene sospesa e ripristinarli quando l'app viene attivata dopo la chiusura.The system doesn't notify an app when it's terminated, so your app must save its application data and release exclusive resources and file handles when it's suspended, and restore them when the app is activated after termination.

Se esegui una chiamata asincrona nel tuo gestore, il controllo viene immediatamente restituito da quella chiamata asincrona.If you make an asynchronous call within your handler, control returns immediately from that asynchronous call. In altre parole, l'esecuzione può quindi essere restituita dal gestore eventi e l'app passerà allo stato successivo anche se la chiamata asincrona non è ancora stata completata.That means that execution can then return from your event handler and your app will move to the next state even though the asynchronous call hasn't completed yet. Usare il metodo Getdifferiment sull'oggetto EnteredBackgroundEventArgs passato al gestore eventi per ritardare la sospensione fino a quando non si chiama il metodo complete sull'oggetto Windows. Foundation. rinvio restituito.Use the GetDeferral method on the EnteredBackgroundEventArgs object that is passed to your event handler to delay suspension until after you call the Complete method on the returned Windows.Foundation.Deferral object.

Un differimento non aumenta la quantità di codice che devi eseguire prima che l'app venga terminata.A deferral doesn't increase the amount you have to run your code before your app is terminated. Rimanda solo la terminazione fino a quando non viene chiamato il metodo Complete del differimento o non viene superata la scadenza, qualunque si verifichi per primo.It only delays termination until either the deferral's Complete method is called, or the deadline passes-whichever comes first. Per estendere il tempo nello stato di sospensione, usare ExtendedExecutionSessionTo extend time in the Suspending state use ExtendedExecutionSession

Nota

Per migliorare la velocità di risposta del sistema in Windows 8.1, alle app viene assegnato l'accesso con priorità bassa alle risorse dopo che sono state sospese.To improve system responsiveness in Windows 8.1, apps are given low priority access to resources after they are suspended. Per supportare questa nuova priorità, il timeout per l'operazione di sospensione viene esteso in modo che l'app disponga dell'equivalente del timeout di 5 secondi per la priorità normale in Windows e di un timeout compreso tra 1 e 10 secondi in Windows Phone.To support this new priority, the suspend operation timeout is extended so that the app has the equivalent of the 5-second timeout for normal priority on Windows or between 1 and 10 seconds on Windows Phone. Non puoi estendere o modificare questa finestra di timeout.You cannot extend or alter this timeout window.

Nota sul debug con Visual Studio: Visual Studio impedisce a Windows di sospendere un'app collegata al debugger.A note about debugging using Visual Studio: Visual Studio prevents Windows from suspending an app that is attached to the debugger. Lo scopo di questo comportamento è consentire all'utente di visualizzare l'interfaccia utente di debug di Visual Studio durante l'esecuzione dell'app.This is to allow the user to view the Visual Studio debug UI while the app is running. Durante il debug di un'app, puoi inviare a essa un evento di sospensione tramite Visual Studio.When you're debugging an app, you can send it a suspend event using Visual Studio. Assicurati che la barra degli strumenti Posizione di debug sia visualizzata, quindi fai clic sull'icona Sospendi.Make sure the Debug Location toolbar is being shown, then click the Suspend icon.