Partager via

Créer et héberger une extension d’application

  • Article

Cet article explique comment créer une extension d’application Windows 10 et l’héberger dans une application. Les extensions d’application sont prises en charge dans les applications UWP et les applications de bureau empaquetées.

Pour montrer comment créer une extension d’application, cet article utilise des extraits de code et XML de manifeste de package à partir de l’exemple de code Math Extension. Cet exemple est une application UWP, mais les fonctionnalités illustrées dans l’exemple s’appliquent également aux applications de bureau empaquetées. Suivez ces instructions pour commencer à utiliser l’exemple :

  • Téléchargez et décompressez l’exemple de code d’extension mathématique.
  • Dans Visual Studio 2019, ouvrez MathExtensionSample.sln. Définissez le type de build sur x86 (Build>Configuration Manager, puis remplacez Platform par x86 pour les deux projets).
  • Déployez la solution : Générer une>solution de déploiement.

Présentation des extensions d’application

Dans Windows 10, les extensions d’application fournissent des fonctionnalités similaires aux plug-ins, compléments et modules complémentaires sur d’autres plateformes. Les extensions d’application ont été introduites dans Windows 10 Édition anniversaire (version 1607, build 10.0.14393).

Les extensions d’application sont des applications UWP ou des applications de bureau empaquetées qui ont une déclaration d’extension qui leur permet de partager du contenu et des événements de déploiement avec une application hôte. Une application d’extension peut fournir plusieurs extensions.

Étant donné que les extensions d’application sont uniquement des applications UWP ou des applications de bureau empaquetées, elles peuvent également être des applications entièrement fonctionnelles, des extensions d’hôte et fournir des extensions à d’autres applications, sans créer de packages d’applications distincts.

Lorsque vous créez un hôte d’extension d’application, vous créez une opportunité de développer un écosystème autour de votre application dans lequel d’autres développeurs peuvent améliorer votre application de manière à ce que vous n’ayez peut-être pas prévu ni eu les ressources nécessaires. Tenez compte des extensions Microsoft Office, des extensions Visual Studio, des extensions de navigateur, etc. Celles-ci créent des expériences plus riches pour ces applications qui vont au-delà des fonctionnalités qu’elles ont fournies. Les extensions peuvent ajouter de la valeur et de la longévité à votre application.

À un niveau élevé, pour configurer une relation d’extension d’application, nous devons :

  1. Déclarez une application comme hôte d’extension.
  2. Déclarez une application comme une extension.
  3. Déterminez s’il faut implémenter l’extension en tant que service d’application, tâche en arrière-plan ou d’une autre façon.
  4. Définissez la façon dont les hôtes et ses extensions communiqueront.
  5. Utilisez l’API Windows.ApplicationModel.AppExtensions dans l’application hôte pour accéder aux extensions.

Voyons comment cela est fait en examinant l’exemple de code d’extension mathématique qui implémente une calculatrice hypothétique à laquelle vous pouvez ajouter de nouvelles fonctions à l’aide d’extensions. Dans Microsoft Visual Studio 2019, chargez MathExtensionSample.sln à partir de l’exemple de code.

Exemple de code d’extension mathématique

Déclarer une application comme hôte d’extension

Une application s’identifie comme hôte d’extension d’application en déclarant l’élément <AppExtensionHost> dans son fichier Package.appxmanifest. Consultez le fichier Package.appxmanifest dans le projet MathExtensionHost pour voir comment cela est fait.

Package.appxmanifest dans le projet MathExtensionHost

<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  IgnorableNamespaces="uap uap3 mp">
  ...
    <Applications>
      <Application Id="App" ... >
        ...
        <Extensions>
            <uap3:Extension Category="windows.appExtensionHost">
                <uap3:AppExtensionHost>
                  <uap3:Name>com.microsoft.mathext</uap3:Name>
                </uap3:AppExtensionHost>
          </uap3:Extension>
        </Extensions>
      </Application>
    </Applications>
    ...
</Package>

Notez la présence et la xmlns:uap3="http://..." présence de uap3 .IgnorableNamespaces Ces éléments sont nécessaires, car nous utilisons l’espace de noms uap3.

<uap3:Extension Category="windows.appExtensionHost"> identifie cette application en tant qu’hôte d’extension.

L’élément Name dans <uap3:AppExtensionHost> est le nom du contrat d’extension. Quand une extension spécifie le même nom de contrat d’extension, l’hôte peut la trouver. Par convention, nous vous recommandons de créer le nom du contrat d’extension en utilisant votre nom d’application ou d’éditeur pour éviter les collisions potentielles avec d’autres noms de contrats d’extension.

Vous pouvez définir plusieurs hôtes et plusieurs extensions dans la même application. Dans cet exemple, nous déclarons un hôte. L’extension est définie dans une autre application.

Déclarer une application comme une extension

Une application s’identifie comme une extension d’application en déclarant l’élément <uap3:AppExtension> dans son fichier Package.appxmanifest . Ouvrez le fichier Package.appxmanifest dans le projet MathExtension pour voir comment cela est fait.

Package.appxmanifest dans le projet MathExtension :

<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  IgnorableNamespaces="uap uap3 mp">
  ...
    <Applications>
      <Application Id="App" ... >
        ...
        <Extensions>
          ...
          <uap3:Extension Category="windows.appExtension">
            <uap3:AppExtension Name="com.microsoft.mathext"
                               Id="power"
                               DisplayName="x^y"
                               Description="Exponent"
                               PublicFolder="Public">
              <uap3:Properties>
                <Service>com.microsoft.powservice</Service>
              </uap3:Properties>
              </uap3:AppExtension>
          </uap3:Extension>
        </Extensions>
      </Application>
    </Applications>
    ...
</Package>

Là encore, notez la ligne xmlns:uap3="http://..." et la présence de uap3 dans IgnorableNamespaces. Ces éléments sont nécessaires, car nous utilisons l’espace uap3 de noms.

<uap3:Extension Category="windows.appExtension"> identifie cette application en tant qu’extension.

La signification des <uap3:AppExtension> attributs est la suivante :

Attribut Description Obligatoire
Nom Il s’agit du nom de contrat d’extension. Quand il correspond à l’attribut Name déclaré dans un hôte, cet hôte peut trouver l’extension. ✔️
ID Identifie de manière unique cette extension. Dans la mesure où il peut exister plusieurs extensions qui utilisent le même nom de contrat d’extension (imaginez une application de dessin qui prend en charge plusieurs extensions), vous pouvez utiliser l’ID pour les distinguer. Les hôtes d’extension d’application peuvent utiliser l’ID pour déduire quelque chose sur le type d’extension. Par exemple, vous pouvez avoir une extension conçue pour les applications de bureau et une autre pour les applications mobiles, l’ID étant le différenciateur. Vous pouvez également utiliser l’élément Properties, présenté ci-dessous, dans ce but. ✔️
DisplayName Peut être utilisé à partir de votre application hôte pour identifier l’extension auprès de l’utilisateur. Il est interrogeable à partir du nouveau système de gestion des ressources (ms-resource:TokenName), et peut l’utiliser à des fins de localisation. Le contenu localisé est chargé à partir du package d’extension d’application, et non à partir de l’application hôte.
Description Peut être utilisé à partir de votre application hôte pour décrire l’extension à l’utilisateur. Il est interrogeable à partir du nouveau système de gestion des ressources (ms-resource:TokenName), et peut l’utiliser à des fins de localisation. Le contenu localisé est chargé à partir du package d’extension d’application, et non à partir de l’application hôte.
PublicFolder Nom d’un dossier, relatif à la racine du package, où vous pouvez partager du contenu avec l’hôte d’extension. Par convention, le nom est « Public », mais vous pouvez utiliser n’importe quel nom qui correspond à un dossier dans votre extension. ✔️

<uap3:Properties> est un élément facultatif qui contient des métadonnées personnalisées que les hôtes peuvent lire au moment de l’exécution. Dans l’exemple de code, l’extension est implémentée en tant que service d’application. L’hôte a donc besoin d’un moyen d’obtenir le nom de ce service d’application pour pouvoir l’appeler. Le nom du service d’application est défini dans l’élément <Service>, que nous avons défini (nous aurions pu l’appeler comme nous le souhaitions). L’hôte de l’exemple de code recherche cette propriété au moment de l’exécution pour connaître le nom du service d’application.

Déterminez la façon dont vous allez implémenter l’extension.

La session Build 2016 sur les extensions d’application montre comment utiliser le dossier public partagé entre l’hôte et les extensions. Dans cet exemple, l’extension est implémentée par un fichier JavaScript stocké dans le dossier public, que l’hôte appelle. Cette approche présente l’avantage d’être légère, ne nécessite pas de compilation et peut prendre en charge la création de la page d’accueil par défaut qui fournit des instructions pour l’extension et un lien vers la page du Microsoft Store de l’application hôte. Pour plus d’informations, consultez l’exemple de code d’extension d’application Build 2016. Plus précisément, consultez le projet InvertImageExtension et InvokeLoad() dans ExtensionManager.cs dans le projet ExtensibilitySample .

Dans cet exemple, nous allons utiliser un service d’application pour implémenter l’extension. Les services d’application présentent les avantages suivants :

  • Si l’extension se bloque, elle ne retire pas l’application hôte, car l’application hôte s’exécute dans son propre processus.
  • Vous pouvez utiliser la langue de votre choix pour implémenter le service. Il n’est pas obligé de faire correspondre le langage utilisé pour implémenter l’application hôte.
  • Le service d’application a accès à son propre conteneur d’application, qui peut avoir des fonctionnalités différentes de celles de l’hôte.
  • Il existe une isolation entre les données dans le service et l’application hôte.

Code du service d’application hôte

Voici le code hôte qui appelle le service d’application de l’extension :

ExtensionManager.cs dans le projet MathExtensionHost

public async Task<double> Invoke(ValueSet message)
{
    if (Loaded)
    {
        try
        {
            // make the app service call
            using (var connection = new AppServiceConnection())
            {
                // service name is defined in appxmanifest properties
                connection.AppServiceName = _serviceName;
                // package Family Name is provided by the extension
                connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;

                // open the app service connection
                AppServiceConnectionStatus status = await connection.OpenAsync();
                if (status != AppServiceConnectionStatus.Success)
                {
                    Debug.WriteLine("Failed App Service Connection");
                }
                else
                {
                    // Call the app service
                    AppServiceResponse response = await connection.SendMessageAsync(message);
                    if (response.Status == AppServiceResponseStatus.Success)
                    {
                        ValueSet answer = response.Message as ValueSet;
                        if (answer.ContainsKey("Result")) // When our app service returns "Result", it means it succeeded
                        {
                            return (double)answer["Result"];
                        }
                    }
                }
            }
        }
        catch (Exception)
        {
             Debug.WriteLine("Calling the App Service failed");
        }
    }
    return double.NaN; // indicates an error from the app service
}

Il s’agit d’un code classique pour appeler un service d’application. Pour plus d’informations sur l’implémentation et l’appel d’un service d’application, consultez Comment créer et consommer un service d’application.

Une chose à noter est la façon dont le nom du service d’application à appeler est déterminé. Étant donné que l’hôte n’a pas d’informations sur l’implémentation de l’extension, l’extension doit fournir le nom de son service d’application. Dans l’exemple de code, l’extension déclare le nom du service d’application dans son fichier dans l’élément <uap3:Properties> :

Package.appxmanifest dans le projet MathExtension

    ...
    <uap3:Extension Category="windows.appExtension">
      <uap3:AppExtension ...>
        <uap3:Properties>
          <Service>com.microsoft.powservice</Service>
        </uap3:Properties>
        </uap3:AppExtension>
    </uap3:Extension>

Vous pouvez définir votre propre code XML dans l’élément <uap3:Properties> . Dans ce cas, nous définissons le nom du service d’application afin que l’hôte puisse le faire lorsqu’il appelle l’extension.

Lorsque l’hôte charge une extension, le code comme celui-ci extrait le nom du service à partir des propriétés définies dans le package.appxmanifest de l’extension :

Update() dans ExtensionManager.cs, dans le projet MathExtensionHost

...
var properties = await ext.GetExtensionPropertiesAsync() as PropertySet;

...
#region Update Properties
// update app service information
_serviceName = null;
if (_properties != null)
{
   if (_properties.ContainsKey("Service"))
   {
       PropertySet serviceProperty = _properties["Service"] as PropertySet;
       this._serviceName = serviceProperty["#text"].ToString();
   }
}
#endregion

Avec le nom du service d’application stocké dans _serviceName, l’hôte peut l’utiliser pour appeler le service d’application.

L’appel d’un service d’application nécessite également le nom de famille du package qui contient le service d’application. Heureusement, l’API d’extension d’application fournit ces informations qui sont obtenues dans la ligne : connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;

Définir la façon dont l’hôte et l’extension communiquent

Les services d’application utilisent un ValueSet pour échanger des informations. En tant qu’auteur de l’hôte, vous devez trouver un protocole pour communiquer avec des extensions flexibles. Dans l’exemple de code, cela signifie que la comptabilité des extensions qui peuvent prendre 1, 2 ou plus d’arguments à l’avenir.

Pour cet exemple, le protocole pour les arguments est un ValueSet contenant les paires clé valeur nommées « Arg » + le numéro d’argument, par exemple Arg1 et Arg2. L’hôte transmet tous les arguments dans ValueSet, et l’extension utilise celles dont elle a besoin. Si l’extension est en mesure de calculer un résultat, l’hôte s’attend à ce que l’ensemble de valeurs retourné par l’extension ait une clé nommée Result qui contient la valeur du calcul. Si cette clé n’est pas présente, l’hôte suppose que l’extension n’a pas pu effectuer le calcul.

Code app service d’extension

Dans l’exemple de code, le service d’application de l’extension n’est pas implémenté en tant que tâche en arrière-plan. Au lieu de cela, il utilise le modèle app service à processus unique dans lequel le service d’application s’exécute dans le même processus que l’application d’extension qui l’héberge. Il s’agit toujours d’un processus différent de l’application hôte, offrant les avantages de la séparation des processus, tout en obtenant des avantages en matière de performances en évitant la communication interprocessus entre le processus d’extension et le processus en arrière-plan qui implémente le service d’application. Consultez Convertir un service d’application pour qu’il s’exécute dans le même processus que son application hôte pour voir la différence entre un service d’application qui s’exécute en tant que tâche en arrière-plan et dans le même processus.

Le système est activé OnBackgroundActivate() lorsque le service d’application est activé. Ce code configure des gestionnaires d’événements pour gérer l’appel d’app service réel quand il s’agit (OnAppServiceRequestReceived()) ainsi que pour gérer les événements de nettoyage, tels que l’obtention d’un objet de report qui gère un événement d’annulation ou fermé.

App.xaml.cs dans le projet MathExtension.

protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
    base.OnBackgroundActivated(args);

    if ( _appServiceInitialized == false ) // Only need to setup the handlers once
    {
        _appServiceInitialized = true;

        IBackgroundTaskInstance taskInstance = args.TaskInstance;
        taskInstance.Canceled += OnAppServicesCanceled;

        AppServiceTriggerDetails appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
        _appServiceDeferral = taskInstance.GetDeferral();
        _appServiceConnection = appService.AppServiceConnection;
        _appServiceConnection.RequestReceived += OnAppServiceRequestReceived;
        _appServiceConnection.ServiceClosed += AppServiceConnection_ServiceClosed;
    }
}

Le code qui effectue le travail de l’extension est dans OnAppServiceRequestReceived(). Cette fonction est appelée lorsque le service d’application est appelé pour effectuer un calcul. Il extrait les valeurs dont il a besoin à partir de ValueSet. S’il peut effectuer le calcul, il place le résultat, sous une clé nommée Result, dans le ValueSet retourné à l’hôte. Rappelez-vous que, selon le protocole défini pour la façon dont cet hôte et ses extensions communiquent, la présence d’une clé de résultat indique la réussite ; sinon, échec.

App.xaml.cs dans le projet MathExtension.

private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
    // Get a deferral because we use an awaitable API below (SendResponseAsync()) to respond to the message
    // and we don't want this call to get cancelled while we are waiting.
    AppServiceDeferral messageDeferral = args.GetDeferral();
    ValueSet message = args.Request.Message;
    ValueSet returnMessage = new ValueSet();

    double? arg1 = Convert.ToDouble(message["arg1"]);
    double? arg2 = Convert.ToDouble(message["arg2"]);
    if (arg1.HasValue && arg2.HasValue)
    {
        returnMessage.Add("Result", Math.Pow(arg1.Value, arg2.Value)); // For this sample, the presence of a "Result" key will mean the call succeeded
    }

    await args.Request.SendResponseAsync(returnMessage);
    messageDeferral.Complete();
}

Gérer les extensions

Maintenant que nous avons vu comment implémenter la relation entre un hôte et ses extensions, voyons comment un hôte trouve des extensions installées sur le système et réagit à l’ajout et à la suppression de packages contenant des extensions.

Le Microsoft Store fournit des extensions en tant que packages. AppExtensionCatalog recherche des packages installés qui contiennent des extensions correspondant au nom du contrat d’extension de l’hôte et fournit des événements qui se déclenchent lorsqu’un package d’extension d’application pertinent pour l’hôte est installé ou supprimé.

Dans l’exemple de code, la ExtensionManager classe (définie dans ExtensionManager.cs dans le projet MathExtensionHost ) encapsule la logique de chargement des extensions et de réponse aux installations et désinstallations du package d’extension.

Le ExtensionManager constructeur utilise la AppExtensionCatalog méthode pour rechercher les extensions d’application sur le système qui ont le même nom de contrat d’extension que l’hôte :

ExtensionManager.cs dans le projet MathExtensionHost.

public ExtensionManager(string extensionContractName)
{
   // catalog & contract
   ExtensionContractName = extensionContractName;
   _catalog = AppExtensionCatalog.Open(ExtensionContractName);
   ...
}

Lorsqu’un package d’extension est installé, il ExtensionManager collecte des informations sur les extensions du package qui ont le même nom de contrat d’extension que l’hôte. Une installation peut représenter une mise à jour dans le cas où les informations de l’extension affectée sont mises à jour. Lorsqu’un package d’extension est désinstallé, les ExtensionManager informations sur les extensions affectées sont supprimées afin que l’utilisateur sache quelles extensions ne sont plus disponibles.

La Extension classe (définie dans ExtensionManager.cs dans le projet MathExtensionHost ) a été créée pour que l’exemple de code accède à l’ID, à la description, au logo et à l’application d’une extension, par exemple si l’utilisateur a activé l’extension.

Pour dire que l’extension est chargée (voir Load() dans ExtensionManager.cs) signifie que l’état du package est correct et que nous avons obtenu son ID, son logo, sa description et son dossier public (que nous n’utilisons pas dans cet exemple pour montrer comment vous l’obtenez). Le package d’extension lui-même n’est pas chargé.

Le concept de déchargement est utilisé pour assurer le suivi des extensions qui ne doivent plus être présentées à l’utilisateur.

Il ExtensionManager fournit des instances de collection Extension afin que les extensions, leurs noms, descriptions et logos puissent être liés aux données liées à l’interface utilisateur. La page ExtensionsTab lie à cette collection et fournit une interface utilisateur pour activer/désactiver des extensions, ainsi que pour les supprimer.

Exemple d’interface utilisateur de l’onglet Extensions

Lorsqu’une extension est supprimée, le système invite l’utilisateur à vérifier qu’il souhaite désinstaller le package qui contient l’extension (et éventuellement d’autres extensions). Si l’utilisateur accepte, le package est désinstallé et les ExtensionManager extensions du package désinstallé sont supprimées de la liste des extensions disponibles pour l’application hôte.

Désinstaller l’interface utilisateur

Débogage des extensions et des hôtes d’application

Souvent, l’hôte d’extension et l’extension ne font pas partie de la même solution. Dans ce cas, pour déboguer l’hôte et l’extension :

  1. Chargez votre projet hôte dans une instance de Visual Studio.
  2. Chargez votre extension dans une autre instance de Visual Studio.
  3. Lancez votre application hôte dans le débogueur.
  4. Lancez l’application d’extension dans le débogueur. (Si vous souhaitez déployer l’extension, au lieu de la déboguer, pour tester l’événement d’installation du package de l’hôte, effectuez Générer une > solution de déploiement, à la place).

Vous pourrez maintenant atteindre des points d’arrêt dans l’hôte et l’extension. Si vous commencez à déboguer l’application d’extension elle-même, vous verrez une fenêtre vide pour l’application. Si vous ne souhaitez pas voir la fenêtre vide, vous pouvez modifier les paramètres de débogage du projet d’extension pour ne pas lancer l’application, mais le déboguer au démarrage (cliquez avec le bouton droit sur le projet d’extension, >propriétés de> débogage sélectionnez Ne pas lancer, mais déboguer mon code au démarrage) Vous devrez toujours démarrer le débogage (F5) le projet d’extension, mais il attend que l’hôte active l’extension, puis que vos points d’arrêt dans l’extension soient atteints.

Déboguer l’exemple de code

Dans l’exemple de code, l’hôte et l’extension se trouvent dans la même solution. Procédez comme suit pour déboguer :

  1. Vérifiez que MathExtensionHost est le projet de démarrage (cliquez avec le bouton droit sur le projet MathExtensionHost , cliquez sur Définir comme projet StartUp).
  2. Placez un point Invoke d’arrêt dans ExtensionManager.cs, dans le projet MathExtensionHost .
  3. F5 pour exécuter le projet MathExtensionHost .
  4. Placez un point OnAppServiceRequestReceived d’arrêt dans App.xaml.cs dans le projet MathExtension .
  5. Démarrez le débogage du projet MathExtension (cliquez avec le bouton droit sur le projet MathExtension , Debug > Start new instance) qui le déploie et déclenche l’événement d’installation du package dans l’hôte.
  6. Dans l’application MathExtensionHost , accédez à la page Calcul , puis cliquez sur x^y pour activer l’extension. Le Invoke() point d’arrêt est atteint en premier et vous pouvez voir l’appel des extensions app service en cours. Ensuite, la OnAppServiceRequestReceived() méthode de l’extension est atteinte et vous pouvez voir que le service d’application calcule le résultat et le retourne.

Résolution des problèmes d’extensions implémentées en tant que service d’application

Si votre hôte d’extension a des difficultés à se connecter au service d’application pour votre extension, vérifiez que l’attribut <uap:AppService Name="..."> correspond à ce que vous avez placé dans votre <Service> élément. S’ils ne correspondent pas, le nom de service que votre extension fournit à l’hôte ne correspond pas au nom du service d’application que vous avez implémenté et l’hôte ne pourra pas activer votre extension.

Package.appxmanifest dans le projet MathExtension :

<Extensions>
   <uap:Extension Category="windows.appService">
     <uap:AppService Name="com.microsoft.sqrtservice" />      <!-- This must match the contents of <Service>...</Service> -->
   </uap:Extension>
   <uap3:Extension Category="windows.appExtension">
     <uap3:AppExtension Name="com.microsoft.mathext" Id="sqrt" DisplayName="Sqrt(x)" Description="Square root" PublicFolder="Public">
       <uap3:Properties>
         <Service>com.microsoft.powservice</Service>   <!-- this must match <uap:AppService Name=...> -->
       </uap3:Properties>
     </uap3:AppExtension>
   </uap3:Extension>
</Extensions>

Liste de contrôle des scénarios de base à tester

Lorsque vous générez un hôte d’extension et que vous êtes prêt à tester comment il prend en charge les extensions, voici quelques scénarios de base à essayer :

  • Exécutez l’hôte, puis déployez une application d’extension
    • L’hôte récupère-t-il de nouvelles extensions qui viennent en cours d’exécution ?
  • Déployez l’application d’extension, puis déployez et exécutez l’hôte.
    • L’hôte récupère-t-il des extensions existantes ?
  • Exécutez l’hôte, puis supprimez l’application d’extension.
    • L’hôte détecte-t-il correctement la suppression ?
  • Exécutez l’hôte, puis mettez à jour l’application d’extension vers une version plus récente.
    • L’hôte récupère-t-il correctement la modification et décharge les anciennes versions de l’extension ?

Scénarios avancés à tester :

  • Exécutez l’hôte, déplacez l’application d’extension vers un média amovible, supprimez le média
    • L’hôte détecte-t-il la modification de l’état du package et désactive-t-il l’extension ?
  • Exécutez l’hôte, puis endommagez l’application d’extension (faites-la non valide, signée différemment, etc.)
    • L’hôte détecte-t-il l’extension falsifiée et la gère-t-elle correctement ?
  • Exécutez l’hôte, puis déployez une application d’extension qui a du contenu ou des propriétés non valides
    • L’hôte détecte-t-il le contenu non valide et le gère-t-il correctement ?

Considérations sur la conception

  • Fournissez l’interface utilisateur qui indique à l’utilisateur quelles extensions sont disponibles et leur permet d’activer/de les désactiver. Vous pouvez également envisager d’ajouter des glyphes pour les extensions qui deviennent indisponibles, car un package est hors connexion, etc.
  • Diriger l’utilisateur vers l’emplacement où il peut obtenir des extensions. Peut-être que votre page d’extension peut fournir une requête de recherche du Microsoft Store qui affiche une liste d’extensions qui peuvent être utilisées avec votre application.
  • Réfléchissez à la façon d’informer l’utilisateur de l’ajout et de la suppression des extensions. Vous pouvez créer une notification pour laquelle une nouvelle extension est installée et inviter l’utilisateur à l’activer. Les extensions doivent être désactivées par défaut afin que les utilisateurs soient en contrôle.

Différences entre les extensions d’application et les packages facultatifs

Le différentiateur clé entre les packages facultatifs et les extensions d’application est un écosystème ouvert et un écosystème fermé, et un package dépendant et un package indépendant.

Les extensions d’application participent à un écosystème ouvert. Si votre application peut héberger des extensions d’application, toute personne peut écrire une extension pour votre hôte tant qu’elle se conforme à votre méthode de transmission/réception d’informations à partir de l’extension. Cela diffère des packages facultatifs qui participent à un écosystème fermé où l’éditeur décide qui est autorisé à créer un package facultatif qui peut être utilisé avec l’application.

Les extensions d’application sont des packages indépendants et peuvent être des applications autonomes. Ils ne peuvent pas avoir de dépendance de déploiement sur une autre application. Les packages facultatifs nécessitent le package principal, et ne peuvent pas s’exécuter sans ce dernier.

Un pack d’extension pour un jeu serait un bon candidat pour un package facultatif, car il est étroitement lié au jeu, il ne peut pas s’exécuter indépendamment du jeu, et vous ne souhaiterez peut-être pas que les packs d’extension soient créés par n’importe quel développeur de l’écosystème.

Si ce même jeu avait des modules complémentaires d’interface utilisateur personnalisables ou des thèmes, une extension d’application peut être un bon choix, car l’application fournissant l’extension peut s’exécuter elle-même, et n’importe quel tiers peut les faire.

Notes

Cette rubrique fournit une introduction aux extensions d’application. Les éléments clés à noter sont la création de l’hôte et son marquage comme tel dans son fichier Package.appxmanifest, la création de l’extension et le marquage comme tel dans son fichier Package.appxmanifest, déterminant comment implémenter l’extension (par exemple, un service d’application, une tâche en arrière-plan ou d’autres moyens), en définissant la façon dont l’hôte communiquera avec les extensions, et l’utilisation de l’API AppExtensions pour accéder aux extensions et les gérer.