Liberare memoria quando l'app viene spostata in backgroundFree memory when your app moves to the background

Questo articolo illustra come ridurre la quantità di memoria usata dalla tua app quando passa allo stato in background, in modo che non venga sospesa ed eventualmente terminata.This article shows you how to reduce the amount of memory that your app uses when it moves to the background state so that it won't be suspended and possibly terminated.

Nuovi eventi in backgroundNew background events

Windows 10, versione 1607, introduce due nuovi eventi del ciclo di vita delle applicazioni, EnteredBackground e LeavingBackground.Windows 10, version 1607, introduces two new application lifecycle events, EnteredBackground and LeavingBackground. Questi eventi comunicano alla tua app l'entrata e l'uscita dallo stato in background.These events let your app know when it is entering and leaving the background.

Quando l'app passa allo stato in background, possono cambiare i vincoli di memoria imposti dal sistema.When your app moves into the background, the memory constraints enforced by the system may change. Usa questi eventi per controllare il consumo di memoria corrente e liberare risorse per rimanere al di sotto del limite, in modo che l'app non venga sospesa ed eventualmente terminata mentre è in background.Use these events to check your current memory consumption and free resources in order to stay below the limit so that your app won't be suspended and possibly terminated while it is in the background.

Eventi per controllare l'utilizzo della memoria dell'appEvents for controlling your app's memory usage

MemoryManager.AppMemoryUsageLimitChanging viene generato subito prima della modifica del limite della memoria totale utilizzabile dall'app.MemoryManager.AppMemoryUsageLimitChanging is raised just before the limit of total memory the app can use is changed. Ad esempio, quando l'app si passa allo stato in background e nella Xbox il limite della memoria cambia da 1024 MB a 128 MB.For example, when the app moves into the background and on the Xbox the memory limit changes from 1024MB to 128MB.
Questo è l'evento più importante da gestire per impedire che l'app venga sospesa o terminata dalla piattaforma.This is the most important event to handle to keep the platform from suspending or terminating the app.

MemoryManager.AppMemoryUsageIncreased viene generato quando il consumo di memoria dell'app aumenta a un valore maggiore dell'enumerazione AppMemoryUsageLevel.MemoryManager.AppMemoryUsageIncreased is raised when the app's memory consumption has increased to a higher value in the AppMemoryUsageLevel enumeration. Ad esempio, da Low a Medium.For example, from Low to Medium. Gestire questo evento è facoltativo, ma consigliabile in quanto l'applicazione è ancora responsabile di rimanere sotto il limite.Handling this event is optional but recommended because the application is still responsible for staying under the limit.

MemoryManager.AppMemoryUsageDecreased viene generato quando il consumo di memoria dell'app si riduce a un valore minore dell'enumerazione AppMemoryUsageLevel.MemoryManager.AppMemoryUsageDecreased is raised when the app's memory consumption has decreased to a lower value in the AppMemoryUsageLevel enumeration. Ad esempio, da High a Low.For example, from High to Low. Gestire questo evento è facoltativo, ma indica che l'applicazione potrebbe essere in grado di allocare ulteriore memoria se necessario.Handling this event is optional but indicates the application may be able to allocate additional memory if needed.

Gestire la transizione tra esecuzione in primo piano e in backgroundHandle the transition between foreground and background

Quando l'app passa dalla posizione di primo piano all'esecuzione in background, viene generato l'evento EnteredBackground.When your app moves from the foreground to the background, the EnteredBackground event is raised. Quando torna in primo piano, viene generato l'evento LeavingBackground.When your app returns to the foreground, the LeavingBackground event is raised. Puoi registrare i gestori per questi eventi al momento della creazione dell'app.You can register handlers for these events when your app is created. Nel modello di progetto predefinito, questa operazione viene eseguita nel costruttore della classe App in App.xaml.cs.In the default project template, this is done in the App class constructor in App.xaml.cs.

Poiché l'esecuzione in background consentirà di ridurre le risorse di memoria che l'app può mantenere, è necessario registrarsi anche per gli eventi AppMemoryUsageIncreased e AppMemoryUsageLimitChanging che è possibile usare per verificare l'utilizzo della memoria corrente dell'app e il limite corrente.Because running in the background will reduce the memory resources your app is allowed to retain, you should also register for the AppMemoryUsageIncreased and AppMemoryUsageLimitChanging events which you can use to check your app's current memory usage and the current limit. I gestori di questi eventi sono mostrati negli esempi seguenti.The handlers for these events are shown in the following examples. Per altre informazioni sul ciclo di vita delle app UWP, vedi Ciclo di vita dell'app.For more information on the application lifecycle for UWP apps, see App lifecycle.

public App()
{
    this.InitializeComponent();

    this.Suspending += OnSuspending;

    // Subscribe to key lifecyle events to know when the app
    // transitions to and from foreground and background.
    // Leaving the background is an important transition
    // because the app may need to restore UI.
    this.EnteredBackground += AppEnteredBackground;
    this.LeavingBackground += AppLeavingBackground;

    // During the transition from foreground to background the
    // memory limit allowed for the application changes. The application
    // has a short time to respond by bringing its memory usage
    // under the new limit.
    Windows.System.MemoryManager.AppMemoryUsageLimitChanging += MemoryManager_AppMemoryUsageLimitChanging;

    // After an application is backgrounded it is expected to stay
    // under a memory target to maintain priority to keep running.
    // Subscribe to the event that informs the app of this change.
    Windows.System.MemoryManager.AppMemoryUsageIncreased += MemoryManager_AppMemoryUsageIncreased;
}

Quando viene generato l'evento EnteredBackground , impostare la variabile di rilevamento per indicare che l'utente è attualmente in esecuzione in background.When the EnteredBackground event is raised, set the tracking variable to indicate that you are currently running in the background. Ciò risulterà utile quando scrivi il codice per ridurre l'uso della memoria.This will be useful when you write the code for reducing memory usage.

/// <summary>
/// The application entered the background.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AppEnteredBackground(object sender, EnteredBackgroundEventArgs e)
{
    _isInBackgroundMode = true;

    // An application may wish to release views and view data
    // here since the UI is no longer visible.
    //
    // As a performance optimization, here we note instead that
    // the app has entered background mode with _isInBackgroundMode and
    // defer unloading views until AppMemoryUsageLimitChanging or
    // AppMemoryUsageIncreased is raised with an indication that
    // the application is under memory pressure.
}

Quando l'app passa in background, il sistema riduce il limite di memoria per l'app, per garantire che l'app attualmente in primo piano abbia risorse sufficienti per offrire un'esperienza utente reattiva.When your app transitions to the background, the system reduces the memory limit for the app to ensure that the current foreground app has sufficient resources to provide a responsive user experience

Il gestore dell'evento AppMemoryUsageLimitChanging consente all'app di tenere presente che la memoria assegnata è stata ridotta e fornisce il nuovo limite negli argomenti dell'evento passati al gestore.The AppMemoryUsageLimitChanging event handler lets your app know that its allotted memory has been reduced and provides the new limit in the event arguments passed into the handler. Confronta la proprietà MemoryManager.AppMemoryUsage, che fornisce l'utilizzo corrente dell'app, con la proprietà NewLimit degli argomenti dell'evento, che specifica il nuovo limite.Compare the MemoryManager.AppMemoryUsage property, which provides your app's current usage, to the NewLimit property of the event arguments, which specifies the new limit. Se l'uso di memoria supera il limite, è necessario ridurlo.If your memory usage exceeds the limit, you need to reduce your memory usage.

In questo esempio, l'operazione viene eseguita nel metodo helper ReduceMemoryUsage, definito più avanti in questo articolo.In this example, this is done in the helper method ReduceMemoryUsage, which is defined later in this article.

/// <summary>
/// Raised when the memory limit for the app is changing, such as when the app
/// enters the background.
/// </summary>
/// <remarks>
/// If the app is using more than the new limit, it must reduce memory within 2 seconds
/// on some platforms in order to avoid being suspended or terminated.
///
/// While some platforms will allow the application
/// to continue running over the limit, reducing usage in the time
/// allotted will enable the best experience across the broadest range of devices.
/// </remarks>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MemoryManager_AppMemoryUsageLimitChanging(object sender, AppMemoryUsageLimitChangingEventArgs e)
{
    // If app memory usage is over the limit, reduce usage within 2 seconds
    // so that the system does not suspend the app
    if (MemoryManager.AppMemoryUsage >= e.NewLimit)
    {
        ReduceMemoryUsage(e.NewLimit);
    }
}

Nota

Alcune configurazioni dei dispositivi consentiranno a un'applicazione di continuare l'esecuzione oltre il nuovo limite di memoria finché il sistema non rileva uno stato di risorse insufficienti, altre no.Some device configurations will allow an application to continue running over the new memory limit until the system experiences resource pressure, and some will not. Su Xbox in particolare, le app verranno sospese o terminate se non riducono l'utilizzo di memoria sotto i nuovi limiti entro 2 secondi.On Xbox, in particular, apps will be suspended or terminated if they do not reduce memory to under the new limits within 2 seconds. Questo significa che puoi offrire la migliore esperienza possibile sulla più ampia gamma di dispositivi usando questo evento per ridurre l'utilizzo di risorse al di sotto del limite entro 2 secondi dalla generazione dell'evento.This means that you can deliver the best experience across the broadest range of devices by using this event to reduce resource usage below the limit within 2 seconds of the event being raised.

Anche se l'utilizzo della memoria della tua app è inferiore al limite consentito per le app in background in occasione della prima transizione allo stato in background, l'app potrebbe aumentare l'utilizzo della memoria nel tempo fino ad approssimarsi al limite.It is possible that although your app's memory usage is currently under the memory limit for background apps when it first transitions to the background, it may increase its memory consumption over time and begin to approach the limit. Il gestore AppMemoryUsageIncreased ti offre l'opportunità di verificare l'utilizzo attuale quando aumenta e, se necessario, di liberare memoria.The handler the AppMemoryUsageIncreased provides an opportunity to check your current usage when it increases and, if necessary, free memory.

Controlla se AppMemoryUsageLevel è High o OverLimit e, se è oltre il limite, riduci l'utilizzo di memoria.Check to see if the AppMemoryUsageLevel is High or OverLimit, and if so, reduce your memory usage. In questo esempio il processo viene gestito dal metodo helper ReduceMemoryUsage.In this example this is handled by the helper method, ReduceMemoryUsage. È anche possibile sottoscrivere l'evento AppMemoryUsageDecreased , verificare se l'app è sotto il limite e, in tal caso, sapere che è possibile allocare risorse aggiuntive.You can also subscribe to the AppMemoryUsageDecreased event, check to see if your app is under the limit, and if so then you know you can allocate additional resources.

/// <summary>
/// Handle system notifications that the app has increased its
/// memory usage level compared to its current target.
/// </summary>
/// <remarks>
/// The app may have increased its usage or the app may have moved
/// to the background and the system lowered the target for the app
/// In either case, if the application wants to maintain its priority
/// to avoid being suspended before other apps, it may need to reduce
/// its memory usage.
///
/// This is not a replacement for handling AppMemoryUsageLimitChanging
/// which is critical to ensure the app immediately gets below the new
/// limit. However, once the app is allowed to continue running and
/// policy is applied, some apps may wish to continue monitoring
/// usage to ensure they remain below the limit.
/// </remarks>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MemoryManager_AppMemoryUsageIncreased(object sender, object e)
{
    // Obtain the current usage level
    var level = MemoryManager.AppMemoryUsageLevel;

    // Check the usage level to determine whether reducing memory is necessary.
    // Memory usage may have been fine when initially entering the background but
    // the app may have increased its memory usage since then and will need to trim back.
    if (level == AppMemoryUsageLevel.OverLimit || level == AppMemoryUsageLevel.High)
    {
        ReduceMemoryUsage(MemoryManager.AppMemoryUsageLimit);
    }
}

ReduceMemoryUsage è un metodo helper che puoi implementare per rilasciare memoria quando l'app è oltre il limite di utilizzo consentito durante l'esecuzione in background.ReduceMemoryUsage is a helper method that you can implement to release memory when your app is over the usage limit while running in the background. Il modo in cui rilasciare memoria dipende dalle specifiche della tua app, ma quello consigliato consiste nel chiudere l'interfaccia utente e tutte le altre risorse associate alla visualizzazione dell'app.How you release memory depends on the specifics of your app, but one recommended way to free up memory is to dispose of your UI and the other resources associated with your app view. A tale scopo, assicurati che l'app sia esecuzione nello stato in background e quindi imposta la proprietà Content della finestra dell'app su null e annulla la registrazione dei gestori di eventi dell'interfaccia utente e rimuovi eventuali altri riferimenti alla pagina eventualmente esistenti.To do so, ensure that you are running in the background state then set the Content property of your app's window to null and unregister your UI event handlers and remove any other references you may have to the page. Se non annulli la registrazione dei gestori degli eventi dell'interfaccia utente e non cancelli eventuali altri riferimenti alla pagina che potrebbero esistere, non sarà possibile rilasciare le risorse della pagina.Failing to unregister your UI event handlers and clearing any other references you may have to the page will prevent the page resources from being released. Chiama quindi GC.Collect per recuperare immediatamente la memoria liberata.Then call GC.Collect to reclaim the freed up memory immediately. In genere non è necessario forzare la Garbage Collection perché il sistema si occuperà automaticamente.Typically you don't force garbage collection because the system will take care of it for you. In questo caso specifico, si riduce la quantità di memoria addebitata a questa applicazione, perché passa in background per ridurre la probabilità che il sistema determini che deve terminare l'app per recuperare memoria.In this specific case, we are reducing the amount of memory charged to this application as it goes into the background to reduce the likelihood that the system will determine that it should terminate the app to reclaim memory.

/// <summary>
/// Reduces application memory usage.
/// </summary>
/// <remarks>
/// When the app enters the background, receives a memory limit changing
/// event, or receives a memory usage increased event, it can
/// can optionally unload cached data or even its view content in
/// order to reduce memory usage and the chance of being suspended.
///
/// This must be called from multiple event handlers because an application may already
/// be in a high memory usage state when entering the background, or it
/// may be in a low memory usage state with no need to unload resources yet
/// and only enter a higher state later.
/// </remarks>
public void ReduceMemoryUsage(ulong limit)
{
    // If the app has caches or other memory it can free, it should do so now.
    // << App can release memory here >>

    // Additionally, if the application is currently
    // in background mode and still has a view with content
    // then the view can be released to save memory and
    // can be recreated again later when leaving the background.
    if (isInBackgroundMode && Window.Current.Content != null)
    {
        // Some apps may wish to use this helper to explicitly disconnect
        // child references.
        // VisualTreeHelper.DisconnectChildrenRecursive(Window.Current.Content);

        // Clear the view content. Note that views should rely on
        // events like Page.Unloaded to further release resources.
        // Release event handlers in views since references can
        // prevent objects from being collected.
        Window.Current.Content = null;
    }

    // Run the GC to collect released resources.
    GC.Collect();
}

Durante la Garbage Collection del contenuto della finestra, ogni frame inizia il processo di disconnessione.When the window content is collected, each Frame begins its disconnection process. Se nella struttura ad albero visuale degli oggetti sono presenti pagine al di sotto del contenuto della finestra, queste inizieranno ad attivare l'evento Unloaded.If there are Pages in the visual object tree under the window content, these will begin firing their Unloaded event. Le pagine non possono essere cancellate completamente dalla memoria a meno che tutti i riferimenti ad esse non siano stati rimossi.Pages cannot be completely cleared from memory unless all references to them are removed. Nel callback Unloaded esegui le operazioni seguenti per assicurarti che la memoria venga liberata rapidamente:In the Unloaded callback, do the following to ensure that memory is quickly freed:

  • Cancella e imposta le eventuali strutture di dati di grandi dimensioni nella pagina su null.Clear and set any large data structures in your Page to null.
  • Annulla la registrazione di tutti i gestori eventi che hanno metodi di callback all'interno della pagina.Unregister all event handlers that have callback methods within the Page. Assicurati di registrare i callback durante il gestore dell'evento Loaded per la pagina.Make sure to register those callbacks during the Loaded event handler for the Page. L'evento Loaded viene generato quando l'interfaccia utente è stata ricostituita e la pagina è stata aggiunta alla struttura ad albero visuale degli oggetti.The Loaded event is raised when the UI has been reconstituted and the Page has been added to the visual object tree.
  • Chiama GC.Collect al termine del callback Unloaded per eseguire rapidamente la Garbage Collection delle strutture di dati di grandi dimensioni appena impostate su null.Call GC.Collect at the end of the Unloaded callback to quickly garbage collect any of the large data structures you have just set to null. Anche in questo caso, non è necessario forzare Garbage Collection perché il sistema si occuperà automaticamente.Again, typically you don't force garbage collection because the system will take care of it for you. In questo caso specifico, si riduce la quantità di memoria addebitata a questa applicazione, perché passa in background per ridurre la probabilità che il sistema determini che deve terminare l'app per recuperare memoria.In this specific case, we are reducing the amount of memory charged to this application as it goes into the background to reduce the likelihood that the system will determine that it should terminate the app to reclaim memory.
private void MainPage_Unloaded(object sender, RoutedEventArgs e)
{
   // << free large data sructures and set them to null, here >>

   // Disconnect event handlers for this page so that the garbage
   // collector can free memory associated with the page
   Window.Current.Activated -= Current_Activated;
   GC.Collect();
}

Nel gestore dell'evento LeavingBackground impostare la variabile di rilevamento ( isInBackgroundMode ) per indicare che l'app non è più in esecuzione in background.In the LeavingBackground event handler, set the tracking variable (isInBackgroundMode) to indicate that your app is no longer running in the background. Successivamente, verifica che Content per la finestra corrente sia null. Sarà così se hai eliminato le visualizzazioni dell'app per liberare memoria durante l'esecuzione in background.Next, check to see if the Content of the current window is null-- which it will be if you disposed of your app views in order to clear up memory while you were running in the background. Se il contenuto della finestra è null, ricompila la visualizzazione dell'app.If the window content is null, rebuild your app view. In questo esempio, il contenuto della finestra viene creato nel metodo helper CreateRootFrame.In this example, the window content is created in the helper method CreateRootFrame.

/// <summary>
/// The application is leaving the background.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AppLeavingBackground(object sender, LeavingBackgroundEventArgs e)
{
    // Mark the transition out of the background state
    _isInBackgroundMode = false;

    // Restore view content if it was previously unloaded
    if (Window.Current.Content == null)
    {
        CreateRootFrame(ApplicationExecutionState.Running, string.Empty);
    }
}

Il metodo helper CreateRootFrame ricrea il contenuto della visualizzazione per la tua app.The CreateRootFrame helper method recreates the view content for your app. Il codice in questo metodo è quasi identico al codice del gestore OnLaunched fornito nel modello di progetto predefinito.The code in this method is nearly identical to the OnLaunched handler code provided in the default project template. L'unica differenza è che il gestore Launching determina lo stato di esecuzione precedente dalla proprietà PreviousExecutionState di LaunchActivatedEventArgs, mentre al metodo CreateRootFrame viene semplicemente passato come argomento.The one difference is that the Launching handler determines the previous execution state from the PreviousExecutionState property of the LaunchActivatedEventArgs and the CreateRootFrame method simply gets the previous execution state passed in as an argument. Per ridurre al minimo il codice duplicato, puoi effettuare il refactoring del codice del gestore eventi Launching predefinito per chiamare CreateRootFrame.To minimize duplicated code, you can refactor the default Launching event handler code to call CreateRootFrame.

void CreateRootFrame(ApplicationExecutionState previousExecutionState, string arguments)
{
    Frame rootFrame = Window.Current.Content as Frame;

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // Create a Frame to act as the navigation context and navigate to the first page
        rootFrame = new Frame();

        // Set the default language
        rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

        rootFrame.NavigationFailed += OnNavigationFailed;

        if (previousExecutionState == ApplicationExecutionState.Terminated)
        {
            //TODO: Load state from previously suspended application
        }

        // Place the frame in the current Window
        Window.Current.Content = rootFrame;
    }

    if (rootFrame.Content == null)
    {
        // When the navigation stack isn't restored navigate to the first page,
        // configuring the new page by passing required information as a navigation
        // parameter
        rootFrame.Navigate(typeof(MainPage), arguments);
    }
}

IndicazioniGuidelines

Passaggio dallo stato in primo piano allo stato in backgroundMoving from the foreground to the background

Quando un'app passa dallo stato in primo piano allo stato in background, il sistema esegue alcune operazioni per conto dell'app per liberare le risorse che non sono necessarie nello stato in background.When an app moves from the foreground to the background, the system does work on behalf of the app to free up resources that are not needed in the background. Ad esempio, il framework dell'interfaccia utente svuota le trame memorizzate nella cache e il sottosistema video libera la memoria allocata per conto dell'app.For example, the UI frameworks flush cached textures and the video subsystem frees memory allocated on behalf of the app. Un'app dovrà comunque monitorare attentamente l'utilizzo della memoria per evitare che venga sospesa o terminata dal sistema.However, an app will still need to carefully monitor its memory usage to avoid being suspended or terminated by the system.

Quando un'app passa dallo stato in primo piano allo stato in background riceve prima di tutto un evento EnteredBackground e quindi un evento AppMemoryUsageLimitChanging.When an app moves from the foreground to the background it will first get an EnteredBackground event and then a AppMemoryUsageLimitChanging event.

  • Usa l'evento EnteredBackground per liberare le risorse dell'interfaccia utente che sai che non serviranno alla tua app durante l'esecuzione in background.Do use the EnteredBackground event to free up UI resources that you know your app does not need while running in the background. Potresti ad esempio liberare l'immagine della copertina per un brano.For example, you could free the cover art image for a song.
  • Usa l'evento AppMemoryUsageLimitChanging per assicurarti che la tua app usi meno memoria del nuovo limite per lo stato in background.Do use the AppMemoryUsageLimitChanging event to ensure that your app is using less memory than the new background limit. Assicurati di liberare risorse in caso contrario.Make sure that you free up resources if not. Se non esegui questa operazione, l'app potrebbe essere sospesa o terminata in base ai criteri specifici del dispositivo.If you do not, your app may be suspended or terminated according to device specific policy.
  • Richiama manualmente il Garbage Collector se l'app supera il nuovo limite di memoria quando viene generato l'evento AppMemoryUsageLimitChanging.Do manually invoke the garbage collector if your app is over the new memory limit when the AppMemoryUsageLimitChanging event is raised.
  • Usa l'evento AppMemoryUsageIncreased per continuare a monitorare l'uso della memoria della tua app durante l'esecuzione in background se prevedi che cambi.Do use the AppMemoryUsageIncreased event to continue to monitor your app’s memory usage while running in the background if you expect it to change. Se AppMemoryUsageLevel è High o OverLimit, assicurati di liberare risorse.If the AppMemoryUsageLevel is High or OverLimit make sure that you free up resources.
  • Considera la possibilità di liberare risorse dell'interfaccia utente nel gestore dell'evento AppMemoryUsageLimitChanging invece che nel gestore EnteredBackground come misura di ottimizzazione delle prestazioni.Consider freeing UI resources in the AppMemoryUsageLimitChanging event handler instead of in the EnteredBackground handler as a performance optimization. Usa un valore booleano impostato nei gestori degli eventi EnteredBackground/LeavingBackground per rilevare se l'app è in background o in primo piano.Use a boolean value set in the EnteredBackground/LeavingBackground event handlers to track whether the app is in the background or foreground. Nel gestore dell'evento AppMemoryUsageLimitChanging, se AppMemoryUsage è sopra il limite e l'app è eseguita in background (in base al valore booleano) puoi quindi liberare le risorse dell'interfaccia utente.Then in the AppMemoryUsageLimitChanging event handler, if AppMemoryUsage is over the limit and the app is in the background (based on the Boolean value) you can free UI resources.
  • Non eseguire attività di lunga durata nell'evento EnteredBackground, perché la transizione tra applicazioni potrebbe risultare lenta agli occhi dell'utente.Do not perform long running operations in the EnteredBackground event because you can cause the transition between applications to appear slow to the user.

Passaggio dallo stato in background allo stato in primo pianoMoving from the background to the foreground

Quando un'app passa dallo stato in background allo stato in primo piano riceve prima di tutto un evento AppMemoryUsageLimitChanging e quindi un evento LeavingBackground.When an app moves from the background to the foreground, the app will first get an AppMemoryUsageLimitChanging event and then a LeavingBackground event.

  • Usa l'evento LeavingBackground per ricreare le risorse dell'interfaccia utente liberate dalla tua app al momento del passaggio allo stato in background.Do use the LeavingBackground event to recreate UI resources that your app discarded when moving into the background.