Reporter la suspension d’une application avec l’exécution étenduePostpone app suspension with extended execution

Cet article vous explique comment utiliser l’exécution étendue pour retarder l’interruption de votre application, afin qu’elle continue de s’exécuter lorsqu’elle est en mode réduit ou sous l’écran de verrouillage.This article shows you how to use extended execution to postpone when your app is suspended so that it can run while minimized or under the lock screen.

Lorsque l’utilisateur réduit ou ferme l’application, cette dernière adopte l’état interrompu.When the user minimizes or switches away from an app it is put into a suspended state. Sa mémoire est conservée, mais son code ne s’exécute pas.Its memory is maintained, but its code does not run. Cela s’avère tout particulièrement sur l’ensemble des éditions de système d’exploitation dotées d’une interface utilisateur visuelle.This is true across all OS Editions with a visual user interface. Pour en savoir plus sur les situations d’interruption de votre application, voir Cycle de vie des applications.For more details about when your app is suspended, see Application Lifecycle.

Il peut arriver que l’application doive continuer de s’exécuter lorsque l’utilisateur quitte sa page ou lorsqu’elle est réduite, plutôt que d’être interrompue.There are cases where an app may need to keep running, rather than be suspended, when the user navigates away from the app, or while it is minimized. Par exemple, une application de comptage de pas doit continuer à s'exécuter et à suivre les pas même lorsque l’utilisateur quitte sa page pour utiliser d’autres applications.For example, a step counting app needs to keep running and tracking steps even when the user navigates away to use other apps.

Si tel est le cas, le système d’exploitation peut s’assurer lui-même que l’application continue de s’exécuter, ou peut lui demander de continuer à s’exécuter.If an app needs to keep running, either the OS can keep it running, or it can request to keep running. Ainsi, lorsqu’un morceau s’exécute en arrière-plan, le système d’exploitation peut assurer l’exécution de l’application pendant une plus longue période si vous suivez la procédure de la section Lecture multimédia en arrière-plan.For example, when playing audio in the background, the OS can keep an app running longer if you follow these steps for Background Media Playback. Dans le cas contraire, vous devez demander manuellement l’allongement de cette période.Otherwise, you must manually request more time. La durée d’une exécution en arrière-plan peut être de plusieurs minutes, mais vous devez être prêt à gérer la session en cours de révocation à tout moment.The amount of time you may get to perform background execution may be several minutes but you must be prepared to handle the session being revoked at any time. Ces contraintes de temps de cycle de vie des applications sont désactivées pendant que l’application s’exécute sous un débogueur.These application lifecycle time constraints are disabled while the app is running under a debugger. Pour cette raison, il est important de tester l’Exécution étendue et d’autres outils pour reporter la suspension de l'application lorsque celle-ci ne s’exécute pas sous un débogueur ou en utilisant les événements de cycle de vie disponibles dans Visual Studio.For this reason it is important to test Extended Execution and other tools for postponing app suspension while not running under a debugger or by using the Lifecycle Events available in Visual Studio.

Créez une session ExtendedExecutionSession afin de demander davantage de temps pour exécuter une opération en arrière-plan.Create an ExtendedExecutionSession to request more time to complete an operation in the background. Le type de session ExtendedExecutionSession que vous créez est déterminé par la valeur ExtendedExecutionReason que vous indiquez lorsque vous la générez.The kind of ExtendedExecutionSession you create is determined by the ExtendedExecutionReason that you provide when you create it. Il existe trois valeurs d’énumération ExtendedExecutionReason : Unspecified, LocationTracking et SavingData.There are three ExtendedExecutionReason enum values: Unspecified, LocationTracking and SavingData. Une seule ExtendedExecutionSession peut être demandée à tout moment. Si vous tentez de créer une autre session alors qu’une autre est actuellement active, le constructeur ExtendedExecutionSession lève une exception 0x8007139F indiquant que le groupe ou la ressource n’est pas dans l'état correct pour effectuer l'opération demandée.Only one ExtendedExecutionSession can be requested at any time; attempting to create another session while an approved session request is currently active will cause exception 0x8007139F to be thrown from the ExtendedExecutionSession constructor stating that the group or resource is not in the correct state to perform the requested operation. N’utilisez pas les valeurs ExtendedExecutionForegroundSession ni ExtendedExecutionForegroundReason, car elles nécessitent des fonctionnalités restreintes et ne peuvent pas être utilisées dans les applications du Store.Do not use ExtendedExecutionForegroundSession and ExtendedExecutionForegroundReason; they require restricted capabilities and are not available for use in Store applications.

Exécuter en mode réduitRun while minimized

Il existe deux cas où l’exécution étendue peut être utilisée :There are two cases where extended execution can be used:

  • À tout moment pendant l’exécution régulière de premier plan, tandis que l’application est en cours d’exécution.At any point during regular foreground execution, while the application is in the running state.
  • Une fois que l’application a reçu un événement de suspension (le système d’exploitation est sur le point de passer l’application en état suspendu) dans le gestionnaire d’événements de suspension de l’application.After the application has received a suspending event (the OS is about to move the app to the suspended state) in the application’s suspending event handler.

Le code pour ces deux cas est le même, mais l’application se comporte un peu différemment dans chacun.The code for these two cases is the same, but the application behaves a little differently in each. Dans le premier cas, l’application reste en état d’exécution, même si un événement qui déclenche normalement une suspension se produit (par exemple, l’utilisateur quitte la page de l’application).In the first case, the application stays in the running state, even if an event that normally would trigger suspension occurs (for example, the user navigating away from the application). L’application ne recevra jamais un événement de suspension pendant que l’extension de l’exécution est en vigueur.The application will never receive a suspending event while the execution extension is in effect. Lorsque l’extension est supprimée, l’application redevient éligible pour la suspension.When the extension is disposed, the application becomes eligible for suspension again.

Dans le second cas, si l’application passe à l’état suspendu, elle reste en état de suspension pour la période de l’extension.In the second case, if the application is transitioning to the suspended state, it will stay in a suspending state for the period of the extension. Une fois que l’extension a expiré, l’application passe à l’état suspendu sans autre notification.Once the extension expires, the application enters the suspended state without further notification.

Utilisez le paramètre ExtendedExecutionReason.Unspecified lorsque vous créez une session ExtendedExecutionSession si vous voulez demander du temps supplémentaire avant de faire passer l’application en arrière-plan pour les situations de type traitement multimédia, compilation de projet, ou maintien de la connexion réseau.Use ExtendedExecutionReason.Unspecified when you create an ExtendedExecutionSession to request additional time before your app moves into the background for scenarios such as media processing, project compilation, or keeping a network connection alive. Sur les appareils de bureau exécutant Windows 10 pour les éditions de bureau (Famille, Entreprise et Éducation), utilisez cette approche si vous voulez empêcher l’interruption d’une application en mode réduit.On desktop devices running Windows 10 for desktop editions (Home, Pro, Enterprise, and Education), this is the approach to use if an app needs to avoid being suspended while it is minimized.

Demandez une extension d’exécution lorsque vous lancez une opération sur le long cours, afin de reporter la transition de l’application vers l’état Interruption en cours lorsque cette dernière passe en arrière-plan.Request the extension when starting a long running operation in order to defer the Suspending state transition that otherwise occurs when the app moves into the background. Sur les appareils de bureau, les sessions d’exécution étendue créées via le paramètre ExtendedExecutionReason.Unspecified sont soumises à une limite de temps dépendant de la batterie.On desktop devices, extended execution sessions created with ExtendedExecutionReason.Unspecified have a battery-aware time limit. Si l’appareil est branché à une prise murale, la durée de la période d’extension de l’exécution n’est soumise à aucune limite.If the device is connected to wall power, there is no limit to the length of the extended execution time period. Si l’appareil est relié à une batterie, la durée de la période d’extension de l’exécution en arrière-plan est limitée à dix minutes au maximum.If the device is on battery power, the extended execution time period can run up to ten minutes in the background.

Un utilisateur de tablette ou d’ordinateur portable peut rencontrer le même comportement d’exécution sur le long terme au détriment de l’autonomie de la batterie lorsque l’option Autoriser l'application à exécuter des tâches en arrière-plan est sélectionnée dans le paramètre Utilisation de la batterie par application.A tablet or laptop user can get the same long running behavior--at the expense of battery life--when the Allow the app to run background tasks option is selected in Battery usage by app settings. (Pour rechercher cette option sur un ordinateur portable, accédez à Paramètres > Système > Batterie > Utilisation de la batterie par application (le lien sous le pourcentage d'énergie restante dans la batterie) > sélectionnez une application > désactivez Géré par Windows > sélectionnez Autoriser l’application à exécuter des tâches en arrière-plan.(To find this option on a laptop, go to Settings > System > Battery > Battery usage by App (the link under the percent of battery power remaining) > select an app > turn off Managed By Windows > select Allow app to run background tasks.

Sur l’ensemble des éditions de système d’exploitation, ce type de session d’exécution étendue s’arrête lorsque l’appareil adopte l’état de veille connectée.On all OS editions this kind of extended execution session stops when the device enters Connected Standby. Sur les appareils mobiles exécutant Windows 10 Mobile, ce type de session d’exécution étendue s’exécute tant que l’écran est sous tension.On mobile devices running Windows 10 Mobile, this kind of extended execution session will run as long as the screen is on. Lorsque l’écran est hors tension, l’appareil tente immédiatement d’accéder au mode Veille connectée à faible consommation d’énergie.When the screen turns off, the device immediately attempts to enter the low-power Connected-Standby mode. Sur les appareils mobiles, la session continue de s’exécuter, même lorsque l’écran de verrouillage s’affiche.On desktop devices, the session will continue running if the lock screen appears. Une fois l’écran hors tension, l’appareil n’accède pas à l’état de veille connectée avant un certain temps.The device does not enter Connected Standby for a period of time after the screen turns off. Sur l’édition du système d’exploitation de la console Xbox, l’appareil accède à l’état de veille connectée au bout d’une heure, sauf si l’utilisateur modifie la valeur par défaut.On the Xbox OS Edition, the device enters Connect Standby after one hour unless the user changes the default.

Effectuer un suivi de l’emplacement de l’utilisateurTrack the user's location

Lorsque vous créez une session ExtendedExecutionSession, indiquez le paramètre ExtendedExecutionReason.LocationTracking si votre application doit régulièrement consigner l’emplacement de l’utilisateur depuis GeoLocator.Specify ExtendedExecutionReason.LocationTracking when you create an ExtendedExecutionSession if your app needs to regularly log the location from the GeoLocator. Les applications effectuant la navigation et le suivi d’activité physique, afin de surveiller régulièrement l’emplacement de l’utilisateur, doivent utiliser ce motif.Apps for fitness tracking and navigation that need to regularly monitor the user's location and should use this reason.

Une session d’exécution étendue associée au suivi de l’emplacement peut s’exécuter aussi longtemps que nécessaire., y compris lorsque l’écran est verrouillé sur un appareil mobile.A location tracking extended execution session can run as long as needed, including while the screen is locked on a mobile device. Cependant, une seule session de ce type peut s’exécuter pour chaque appareil.However, there can only be one such session running per device. Vous pouvez uniquement demander l’exécution de cette catégorie de session au premier plan ; l’application doit présenter l’état Exécution en cours.A location tracking extended execution session can only be requested in the foreground, and the app must be in the Running state. Cela permet de s’assurer que l’utilisateur est conscient de l’initiation d’une session de suivi d’emplacement étendue par l’application.This ensures that the user is aware that the app has initiated an extended location tracking session. Vous pouvez toujours utiliser la fonction Geolocator lorsque l’application est exécutée à l’arrière-plan. Pour cela, utilisez une tâche en arrière-plan ou un service d’application sans demander de session d’exécution étendue de suivi de l’emplacement.It is still possible to use the GeoLocator while the app is in the background by using a background task, or an app service, without requesting a location tracking extended execution session.

Enregistrement en local des données critiquesSave Critical Data Locally

Il arrive que le fait de ne pas enregistrer des données avant l’arrêt de l’application entraîne une perte de données ou une expérience utilisateur peu satisfaisante. Dans ce cas, spécifiez le paramètre ExtendedExecutionReason.SavingData lorsque vous créez une session ExtendedExecutionSession afin d’enregistrer les données utilisateur.Specify ExtendedExecutionReason.SavingData when you create an ExtendedExecutionSession to save user data in the case where not saving the data before the app is terminated will result in data loss and a negative user experience.

N’utilisez pas ce type de session pour étendre la durée de vie d’une application afin de charger ou de télécharger des données.Don't use this kind of session to extend the lifetime of an app to upload or download data. Pour charger des données, demandez un transfert en arrière-plan ou enregistrez un élément MaintenanceTrigger afin de gérer le transfert lorsque l’alimentation secteur est disponible.If you need to upload data, request a background transfer or register a MaintenanceTrigger to handle the transfer when AC power is available. Vous pouvez demander une session d’exécution étendue ExtendedExecutionReason.SavingData lorsque l’application est au premier plan et présente l’état Exécution en cours, ou à l’arrière-plan, à l’état Interruption en cours.A ExtendedExecutionReason.SavingData extended execution session can be requested either when the app is in the foreground and in the Running state, or in the background and in the Suspending state.

L’état Interruption en cours correspond à la dernière occasion dont dispose l’application pour effectuer des tâches avant son arrêt.The Suspending state is the last opportunity during the app lifecycle that an app can do work before the app is terminated. ExtendedExecutionReason.SavingData est le seul type de ExtendedExecutionSession pouvant être demandé dans l’état Interruption en cours.ExtendedExecutionReason.SavingData is the only type of ExtendedExecutionSession that can be requested in the Suspending state. Le fait de demander une session d’exécution étendue ExtendedExecutionReason.SavingData alors que l’application présente l’état Interruption en cours crée un problème éventuel dont vous devez être informé.Requesting a ExtendedExecutionReason.SavingData extended execution session while the app is in the Suspending state creates a potential issue that you should be aware of. Si une session de ce type est demandée alors que l’état est Interruption en cours, et si l’utilisateur demande un nouveau lancement de l’application, cette dernière peut prendre un certain temps à démarrer.If an extended execution session is requested while in the Suspending state, and the user requests the app be launched again, it may appear to take a long time to launch. En effet, la session d’exécution étendue doit être terminée pour qu’il soit possible de fermer l’ancienne instance de l’application et d’en démarrer une nouvelle.This is because the extended execution session time period must complete before the old instance of the app can be closed and a new instance of the app can be launched. Le délai de performances du lancement est sacrifié de manière à garantir la conservation de l’état utilisateur.Launch performance time is sacrificed in order to guarantee that user state is not lost.

Demande, cession et révocationRequest, disposal, and revocation

Il existe trois interactions fondamentales avec une session d’exécution étendue : demande, suppression et révocation.There are three fundamental interactions with an extended execution session: the request, disposal, and revocation. La création de la demande est indiquée dans l’extrait de code suivant.Making the request is modeled in the following code snippet.

DemandeRequest

var newSession = new ExtendedExecutionSession();
newSession.Reason = ExtendedExecutionReason.Unspecified;
newSession.Revoked += SessionRevoked;
ExtendedExecutionResult result = await newSession.RequestExtensionAsync();

switch (result)
{
    case ExtendedExecutionResult.Allowed:
        DoLongRunningWork();
        break;

    default:
    case ExtendedExecutionResult.Denied:
        DoShortRunningWork();
        break;
}

Voir l’exemple de codeSee code sample

L’appel de l’élément RequestExtensionAsync permet de vérifier auprès du système d’exploitation si l’utilisateur est associé à une activité en arrière-plan approuvée pour l’application, et si le système inclut des ressources disponibles pour permettre l’exécution en arrière-plan.Calling RequestExtensionAsync checks with the operating system to see if the user has approved background activity for the app and whether the system has the available resources to enable background execution. Une seule session est approuvée pour une application à tout moment, par conséquent, tout appel supplémentaire à RequestExtensionAsync entraîne le refus de la session.Only one session will be approved for an app at any time, causing additional calls to RequestExtensionAsync to result in the session being denied.

Vous pouvez vérifier le paramètre BackgroundExecutionManager au préalable afin de déterminer la valeur BackgroundAccessStatus, qui correspond au paramètre utilisateur indiquant si votre application peut s’exécuter en arrière-plan ou non.You can check the BackgroundExecutionManager beforehand to determine the BackgroundAccessStatus, which is the user setting that indicates whether your app can run in the background or not. Pour en savoir plus sur ces paramètres utilisateur, consultez la section relative à l’activité en arrière-plan et à la prise en charge de l’énergie.To learn more about these user settings see Background Activity and Energy Awareness.

L’élément ExtendedExecutionSession indique l’opération effectuée par votre application en arrière-plan.The ExtendedExecutionReason indicates the operation your app is performing in the background. La chaîne Description, lisible par l’utilisateur, explique pourquoi votre application doit effectuer l’opération.The Description string is a human-readable string that explains why your app needs to perform the operation. Cette chaîne n’est pas présentée à l’utilisateur, mais peut être mise à disposition dans une prochaine version de Windows.This string is not presented to the user, but may be made available in a future release of Windows. Le gestionnaire d’événements Revoked est requis pour permettre un arrêt normal de la session d’exécution étendue si l’utilisateur ou le système décide que l’application ne peut plus s’exécuter en arrière-plan.The Revoked event handler is required so that an extended execution session can halt gracefully if the user, or the system, decides that the app can no longer run in the background.

RévocationRevoked

Si une session d’exécution étendue active est associée à une application, et si le système requiert l’arrêt de l’activité en arrière-plan parce qu'une application de premier plan nécessite les ressources, la session est révoquée.If an app has an active extended execution session and the system requires background activity to halt because a foreground application requires the resources, then the session is revoked. Le système n’arrête jamais l’exécution d’une session d’exécution étendue sans avoir lancé le gestionnaire d’événements Revoked au préalable.An extended execution session time period is never terminated without first firing the Revoked event handler.

Si l’événement Revoked est déclenché dans le cas d’une session d’exécution étendue ExtendedExecutionReason.SavingData, l’application dispose d’une seconde pour terminer l’opération en cours et passer à l’état Interruption en cours.When the Revoked event is fired for an ExtendedExecutionReason.SavingData extended execution session, the app has one second to complete the operation it was performing and finish Suspending.

Une révocation peut survenir pour diverses raisons (un quota énergétique en arrière-plan ou l’échéance d’exécution d’une application ont été atteints, ou la mémoire doit être récupérée pour permettre à l’utilisateur d’ouvrir une nouvelle application au premier plan, par exemple).Revocation can occur for many reasons: an execution time limit was reached, a background energy quota was reached, or memory needs to be reclaimed in order for the user to open a new app in the foreground.

Voici un exemple de gestionnaire d’événements Revoked :Here is an example of a Revoked event handler:

private async void SessionRevoked(object sender, ExtendedExecutionRevokedEventArgs args)
{
    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        switch (args.Reason)
        {
            case ExtendedExecutionRevokedReason.Resumed:
                rootPage.NotifyUser("Extended execution revoked due to returning to foreground.", NotifyType.StatusMessage);
                break;

            case ExtendedExecutionRevokedReason.SystemPolicy:
                rootPage.NotifyUser("Extended execution revoked due to system policy.", NotifyType.StatusMessage);
                break;
        }

        EndExtendedExecution();
    });
}

Voir l’exemple de codeSee code sample

SupprimerDispose

La suppression de la session d’exécution étendue constitue l’étape finale.The final step is to dispose of the extended execution session. En effet, il est souhaitable de supprimer la session et toutes les autres ressources utilisant une grande quantité de mémoire, car l’énergie utilisée par l’application pendant qu’elle attend la fermeture de la session est comptabilisée dans la valeur de quota énergétique de cette application.You want to dispose of the session, and any other memory intensive assets, because otherwise the energy used by the app while it is waiting for the session to close will be counted against the app's energy quota. Pour préserver autant que possible le quota énergétique de l’application, vous devez supprimer la session lorsque vous avez terminé votre travail au sein de cette dernière, afin que l’application puisse plus rapidement atteindre l’état Interrompu.To preserve as much of the energy quota for the app as possible, it is important to dispose of the session when you are done with your work for the session so that the app can move into the Suspended state more quickly.

En supprimant vous-même la session, plutôt que d’attendre l’événement de révocation, vous réduisez le pourcentage du quota énergétique utilisé par l’application.Disposing of the session yourself, rather than waiting for the revocation event, reduces your app's energy quota usage. Cela signifie que votre application sera autorisée à s’exécuter en arrière-plan pendant plus longtemps lors des sessions à venir, car le quota énergétique disponible pour permettre cette exécution sera plus important.This means that your app will be permitted to run in the background longer in future sessions because you'll have more energy quota available to do so. Vous devez conserver une référence à l’objet ExtendedExecutionSession jusqu’à la fin de l’opération, afin de pouvoir appeler la méthode Dispose correspondante.You must maintain a reference to the ExtendedExecutionSession object until the end of the operation so that you can call its Dispose method.

Voici un extrait de code représentant la suppression d’une session d’exécution étendue :A snippet that disposes an extended execution session follows:

void ClearExtendedExecution(ExtendedExecutionSession session)
{
    if (session != null)
    {
        session.Revoked -= SessionRevoked;
        session.Dispose();
        session = null;
    }
}

Voir l’exemple de codeSee code sample

Une application ne peut avoir qu’une seule session ExtendedExecutionSession active à la fois.An app can only have one ExtendedExecutionSession active at a time. De nombreuses applications utilisent des tâches asynchrones pour effectuer des opérations complexes, qui nécessitent un accès aux ressources de type stockage, réseau ou services réseau.Many apps use asynchronous tasks in order to complete complex operations that require access to resources such as storage, network, or network-based services. Si l’exécution d’une opération nécessite plusieurs tâches asynchrones, l’état de chaque de ces tâches doit être pris en compte avant la suppression de la session ExtendedExecutionSession et l’interruption de l’application.If an operation requires multiple asynchronous tasks to complete, then the state of each of these tasks must be accounted for before disposing the ExtendedExecutionSession and allowing the app to be suspended. Cela nécessite un décompte de références concernant le nombre de tâches encore en cours ; la session ne peut être supprimée que lorsque cette valeur atteint zéro.This requires reference counting the number of tasks that are still running, and not disposing of the session until that value reaches zero.

Voici un exemple de code permettant de gérer plusieurs tâches pendant une session d’exécution étendue.Here is some example code for managing multiple tasks during an extended execution session period. Pour plus d’informations sur son utilisation dans votre application, consultez l’exemple de code dont le lien figure ci-dessous :For more information on how to use this in your app please see the code sample linked below:

static class ExtendedExecutionHelper
{
    private static ExtendedExecutionSession session = null;
    private static int taskCount = 0;

    public static bool IsRunning
    {
        get
        {
            if (session != null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    public static async Task<ExtendedExecutionResult> RequestSessionAsync(ExtendedExecutionReason reason, TypedEventHandler<object, ExtendedExecutionRevokedEventArgs> revoked, String description)
    {
        // The previous Extended Execution must be closed before a new one can be requested.       
        ClearSession();

        var newSession = new ExtendedExecutionSession();
        newSession.Reason = reason;
        newSession.Description = description;
        newSession.Revoked += SessionRevoked;

        // Add a revoked handler provided by the app in order to clean up an operation that had to be halted prematurely
        if(revoked != null)
        {
            newSession.Revoked += revoked;
        }

        ExtendedExecutionResult result = await newSession.RequestExtensionAsync();

        switch (result)
        {
            case ExtendedExecutionResult.Allowed:
                session = newSession;
                break;
            default:
            case ExtendedExecutionResult.Denied:
                newSession.Dispose();
                break;
        }
        return result;
    }

    public static void ClearSession()
    {
        if (session != null)
        {
            session.Dispose();
            session = null;
        }

        taskCount = 0;
    }

    public static Deferral GetExecutionDeferral()
    {
        if (session == null)
        {
            throw new InvalidOperationException("No extended execution session is active");
        }

        taskCount++;
        return new Deferral(OnTaskCompleted);
    }

    private static void OnTaskCompleted()
    {
        if (taskCount > 0)
        {
            taskCount--;
        }
        
        //If there are no more running tasks than end the extended lifetime by clearing the session
        if (taskCount == 0 && session != null)
        {
            ClearSession();
        }
    }

    private static void SessionRevoked(object sender, ExtendedExecutionRevokedEventArgs args)
    {
        //The session has been prematurely revoked due to system constraints, ensure the session is disposed
        if (session != null)
        {
            session.Dispose();
            session = null;
        }
        
        taskCount = 0;
    }
}

Voir l’exemple de codeSee code sample

Vérifier l’utilisation adéquate des ressources par l’applicationEnsure that your app uses resources well

Il est crucial d’ajuster le taux d’utilisation de l’énergie et de la mémoire par votre application, afin de vérifier que le système d’exploitation va autoriser votre application à poursuivre son exécution lorsqu’elle n’est plus au premier plan.Tuning your app's memory and energy use is key to ensuring that the operating system will allow your app to continue to run when it is no longer the foreground app. Utilisez les API de gestion de la mémoire pour déterminer la quantité de mémoire utilisée par votre application.Use the Memory Management APIs to see how much memory your app is using. Plus votre application utilise de mémoire, plus le système d’exploitation a des difficultés à assurer l’exécution de cette application lorsqu’une autre application se trouve au premier plan.The more memory your app uses, the harder it is for the OS to keep your app running when another app is in the foreground. L’utilisateur dispose d’un contrôle étroit sur l’ensemble des activités en arrière-plan que votre application peut exécuter, et bénéficie d’une visibilité étendue sur l’impact de cette dernière sur le taux d’utilisation de la batterie.The user is ultimately in control of all background activity that your app can perform and has visibility on the impact your app has on battery use.

Utilisez la méthode BackgroundExecutionManager.RequestAccessAsync pour déterminer si l’utilisateur a opté pour une activité limitée de votre application en arrière-plan.Use BackgroundExecutionManager.RequestAccessAsync to determine if the user has decided that your app’s background activity should be limited. Tenez compte du taux d’utilisation de la batterie ; exécutez l’application en arrière-plan uniquement lorsqu’elle est nécessaire dans le cadre d’une action souhaitée par l’utilisateur.Be aware of your battery usage and only run in the background when it is necessary to complete an action that the user wants.

Articles associésSee also

Exemple d’exécution étendueExtended Execution Sample
Cycle de vie des applicationsApplication Lifecycle
Cycle de vie de l’application - Conserver les applications actives avec des tâches en arrière-plan et l'Exécution étendue Gestion de la mémoire en arrière-planApp Lifecycle - Keep Apps Alive with Background Tasks and Extended Execution Background Memory Management
Transferts en arrière-planBackground Transfers
Détection de la batterie et activité en arrière-planBattery Awareness and Background Activity
MemoryManager, classeMemoryManager class
Lire le média en arrière-planPlay Media in the Background