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

  • Article

Cet article vous montre 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 le code XML de manifeste de package et les extraits de code de l’exemple de code d’extension math. Cet exemple est une application UWP, mais les fonctionnalités présenté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 Math Extension.
  • 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éployer la solution : Générer Déployer>la solution.

Présentation des extensions d’application

Dans Windows 10, les extensions d’application fournissent des fonctionnalités similaires à celles des 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 ne sont que des applications UWP ou des applications de bureau empaquetées, elles peuvent également être entièrement fonctionnelles, héberger des extensions et fournir des extensions à d’autres applications, le tout 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 d’une manière que vous n’aviez peut-être pas attendue ou dont vous n’aviez pas les ressources. Prenons l’exemple 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écidez d’implémenter l’extension en tant que service d’application, tâche en arrière-plan ou autre.
  4. Définissez la façon dont les hôtes et leurs extensions communiquent.
  5. Utilisez l’API Windows.ApplicationModel.AppExtensions dans l’application hôte pour accéder aux extensions.

Voyons comment procéder 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 en tant qu’hôte d’extension d’application en déclarant l’élément <AppExtensionHost> dans son fichier Package.appxmanifest. Pour savoir comment procéder, consultez le fichier Package.appxmanifest dans le projet MathExtensionHost .

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 xmlns:uap3="http://..." présence de et dans IgnorableNamespacesuap3 . Celles-ci 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 . Lorsqu’une extension spécifie le même nom de contrat d’extension, l’hôte peut le trouver. Par convention, nous vous recommandons de créer le nom du contrat d’extension à l’aide de votre nom d’application ou d’éditeur pour éviter les collisions potentielles avec d’autres noms de contrat 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 en tant qu’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 procéder.

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>

À nouveau, notez la xmlns:uap3="http://..." ligne et la présence de uap3 dans IgnorableNamespaces. Celles-ci sont nécessaires, car nous utilisons l’espace de uap3 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 du contrat d’extension. Lorsqu’il correspond au nom déclaré dans un hôte, cet hôte peut trouver cette extension. ✔️
Identifiant Identifie de manière unique cette extension. Étant donné qu’il peut y avoir plusieurs extensions qui utilisent le même nom de contrat d’extension (imaginez une application paint 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 du type d’extension. Par exemple, vous pouvez avoir une extension conçue pour le bureau et une autre pour les appareils mobiles, l’ID étant l’élément de différenciation. Vous pouvez également utiliser l’élément Properties , décrit ci-dessous, pour cela. ✔️
DisplayName Peut être utilisé à partir de votre application hôte pour identifier l’extension de l’utilisateur. Il peut être interrogé à partir du nouveau système de gestion des ressources (ms-resource:TokenName) et peut l’utiliser pour la localisation. Le contenu localisé est chargé à partir du package d’extension d’application, et non de l’application hôte.
Description Peut être utilisé à partir de votre application hôte pour décrire l’extension à l’utilisateur. Il peut être interrogé à partir du nouveau système de gestion des ressources (ms-resource:TokenName) et peut l’utiliser pour la localisation. Le contenu localisé est chargé à partir du package d’extension d’application, et non de l’application hôte.
Dossier public Nom d’un dossier, relatif à la racine du package, dans lequel 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, de sorte que l’hôte a besoin d’un moyen d’obtenir le nom de ce service d’application afin qu’il puisse 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 voulions). L’hôte dans l’exemple de code recherche cette propriété au moment de l’exécution pour apprendre 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 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 n’entraîne pas l’arrêt de 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. Elle n’a pas besoin de correspondre à la langue utilisée 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 Création et utilisation d’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 ne dispose 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 quand il appelle l’extension.

Lorsque l’hôte charge une extension, un 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 une classe ValueSet pour échanger des informations. En tant qu’auteur de l’hôte, vous devez trouver un protocole flexible pour communiquer avec des extensions. Dans l’exemple de code, cela signifie la prise en compte 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 passe tous les arguments du ValueSet, et l’extension utilise ceux dont il a besoin. Si l’extension est en mesure de calculer un résultat, l’hôte s’attend à ce que le ValueSet 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 terminer 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, qui offre 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 effectue jusqu’au OnBackgroundActivate() moment où le service d’application est activé. Ce code configure les gestionnaires d’événements pour gérer l’appel d’App Service réel quand il se présente (OnAppServiceRequestReceived()) et gérer les événements de nettoyage tels que l’obtention d’un objet de report gérant un événement d’annulation ou de fermeture.

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 se trouve 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 du ValueSet. S’il peut effectuer le calcul, il place le résultat, sous une clé nommée Result, dans le ValueSet qui est retourné à l’hôte. Rappelez-vous qu’en fonction du protocole défini pour la façon dont cet hôte et ses extensions communiqueront, la présence d’une clé de résultat indiquera 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 les 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 sous forme de packages. AppExtensionCatalog recherche les 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 pour AppExtensionCatalog 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é, le 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, auquel cas les informations de l’extension affectée sont mises à jour. Lorsqu’un package d’extension est désinstallé, le ExtensionManager supprime des informations sur les extensions affecté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 l’exemple de code afin d’accéder à l’ID, à la description, au logo et aux informations spécifiques de l’application d’une extension, telles que si l’utilisateur a activé l’extension.

Dire que l’extension est chargée (voir Load() dans ExtensionManager.cs) signifie que le package status 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, simplement pour montrer comment vous l’obtenez). Le package d’extension lui-même n’est pas en cours de chargement.

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

Fournit ExtensionManager des instances de collection Extension afin que les extensions, leurs noms, descriptions et logos puissent être liés à l’interface utilisateur. La page ExtensionsTab est liée à cette collection et fournit une interface utilisateur permettant d’activer/désactiver des extensions, ainsi que de 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 supprime ExtensionManager les extensions du package désinstallé 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 un 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 de package de l’hôte, effectuez plutôt build > deploy solution).

Vous pouvez 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, une fenêtre vide s’affiche 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 la déboguer au démarrage (cliquez avec le bouton droit sur le projet d’extension, propriétés>Debug> sélectionnez Ne pas lancer, mais déboguer mon code quand il démarre) Vous devez toujours démarrer le débogage (F5) le projet d’extension, mais il attend que l’hôte active l’extension, puis vos points d’arrêt dans l’extension seront 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. Pour déboguer, procédez comme suit :

  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 de démarrage).
  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, Déboguer > Démarrer nouveau instance) pour le déployer et déclencher l’événement d’installation du package sur 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 app service des extensions en cours. Ensuite, la OnAppServiceRequestReceived() méthode dans l’extension est atteinte, et vous pouvez voir le service d’application calculer le résultat et le retourner.

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

Si votre hôte d’extension rencontre des problèmes de connexion au service d’application pour votre extension, assurez-vous 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 fourni par votre extension à l’hôte ne correspondra 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 vérification des scénarios de base à tester

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

  • Exécuter l’hôte, puis déployer une application d’extension
    • L’hôte récupère-t-il de nouvelles extensions qui viennent le long de son 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 précédemment ?
  • 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 la modification et décharge-t-il correctement les anciennes versions de l’extension ?

Scénarios avancés à tester :

  • Exécuter l’hôte, déplacer l’application d’extension sur un média amovible, supprimer le média
    • L’hôte détecte-t-il la modification dans le package status et désactive-t-il l’extension ?
  • Exécutez l’hôte, puis endommagez l’application d’extension (la rendre non valide, signée différemment, etc.)
    • L’hôte détecte-t-il l’extension falsifiée et la gère-t-il 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 ?

Remarques relatives à la conception

  • Fournissez une interface utilisateur qui indique à l’utilisateur les extensions disponibles et lui permet de les activer/désactiver. Vous pouvez également envisager d’ajouter des glyphes pour les extensions qui deviennent indisponibles parce qu’un package est hors connexion, etc.
  • Dirigez 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.
  • Déterminez comment informer l’utilisateur de l’ajout et de la suppression d’extensions. Vous pouvez créer une notification pour le moment où 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 principal élément de différenciation entre les packages facultatifs et les extensions d’application est l’écosystème ouvert et l’écosystème fermé, et le package dépendant et le package indépendant.

Les extensions d’application participent à un écosystème ouvert. Si votre application peut héberger des extensions d’application, n’importe qui peut écrire une extension pour votre hôte tant qu’elle est 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 dans l’écosystème.

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

Remarques

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 son marquage comme tel dans son fichier Package.appxmanifest, la détermination de l’implémentation de l’extension (par exemple, un service d’application, une tâche en arrière-plan ou d’autres moyens), la définition de 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.