Erstellen und Hosten einer App-Erweiterung

In diesem Artikel erfahren Sie, wie Sie eine Windows 10-App-Erweiterung erstellen und in einer App hosten. App-Erweiterungen werden in UWP-Apps und verpackten Desktop-Appsunterstützt.

Um zu veranschaulichen, wie eine App-Erweiterung erstellt wird, verwendet dieser Artikel Xml- und Codeausschnitte des Paketmanifests aus dem Math Extension-Codebeispiel. Dieses Beispiel ist eine UWP-App, aber die im Beispiel gezeigten Features gelten auch für verpackte Desktop-Apps. Führen Sie die folgenden Anweisungen aus, um mit dem Beispiel zu beginnen:

• Laden Sie das Math Extension-Codebeispielherunter, und entpacken Sie es.
• Öffnen Sie in Visual Studio 2019 MathExtensionSample.sln. Legen Sie den Buildtyp auf x86 fest (Build>Configuration Manager, und ändern Sie dann Platform in x86- für beide Projekte).
• Bereitstellen der Lösung: Bauen>Lösung bereitstellen.

Einführung in App-Erweiterungen

In Windows 10, bieten App-Erweiterungen ähnliche Funktionen wie Plug-Ins, Add-Ins und Add-Ons auf anderen Plattformen. App-Erweiterungen wurden in der Windows 10 Anniversary-Edition eingeführt (Version 1607, Build 10.0.14393).

App-Erweiterungen sind UWP-Apps oder verpackte Desktop-Apps mit einer Erweiterungsdeklaration, mit der sie Inhalte und Bereitstellungsereignisse für eine Host-App freigeben können. Eine Erweiterungs-App kann mehrere Erweiterungen bereitstellen.

Da App-Erweiterungen nur UWP-Apps oder verpackte Desktop-Apps sind, können sie auch voll funktionsfähige Apps, Hosterweiterungen sein und Erweiterungen für andere Apps bereitstellen – alles, ohne separate App-Pakete zu erstellen.

Wenn Sie einen App-Erweiterungshost erstellen, schaffen Sie eine Gelegenheit, ein Ökosystem für Ihre App zu entwickeln, in dem andere Entwickler Ihre App auf unerwartete Weise verbessern können, die Ihre eigenen Ressourcen übersteigen könnten. Erwägen Sie Microsoft Office-Erweiterungen, Visual Studio-Erweiterungen, Browsererweiterungen usw. Diese schaffen eine umfangreichere Benutzererfahrung für apps, die über die funktionalität hinausgehen, mit der sie ausgeliefert wurden. Erweiterungen können Ihrer App Mehrwert und Langlebigkeit hinzufügen.

Um eine App-Erweiterungsbeziehung einzurichten, müssen wir auf hoher Ebene:

1. Deklarieren Sie eine App als Erweiterungshost.
2. Deklarieren Sie eine App als Erweiterung.
3. Entscheiden Sie, ob die Erweiterung als App-Dienst, Hintergrundaufgabe oder auf andere Weise implementiert werden soll.
4. Definieren Sie, wie die Hosts und deren Erweiterungen kommunizieren.
5. Verwenden Sie die Windows.ApplicationModel.AppExtensions-API in der Host-App, um auf die Erweiterungen zuzugreifen.

Sehen wir uns an, wie dies geschieht, indem Sie das Math Extension-Codebeispiel untersuchen, das einen hypothetischen Rechner implementiert, dem Sie mithilfe von Erweiterungen neue Funktionen hinzufügen können. Laden Sie in Microsoft Visual Studio 2019 MathExtensionSample.sln aus dem Codebeispiel.

Eine App als Erweiterungshost deklarieren.

Eine App identifiziert sich selbst als App-Erweiterungshost, indem sie das <AppExtensionHost>-Element in ihrer Datei "Package.appxmanifest" deklariert. Sehen Sie sich die datei Package.appxmanifest im MathExtensionHost- Projekt an, um zu sehen, wie dies geschieht.

Package.appxmanifest im MathExtensionHost-Projekt

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

Beachten Sie die xmlns:uap3="http://..." und das Vorhandensein von uap3 in IgnorableNamespaces. Diese sind erforderlich, da wir den uap3-Namespace verwenden.

<uap3:Extension Category="windows.appExtensionHost"> identifiziert diese App als Erweiterungshost.

Das Name--Element in <uap3:AppExtensionHost> ist der Name des -Erweiterungsvertrags. Wenn eine Erweiterung denselben Erweiterungsvertragsnamen angibt, kann der Host ihn finden. Nach Konvention empfehlen wir, den Namen des Erweiterungsvertrags unter Verwendung Ihres App- oder Herausgebernamens zu bilden, um potenzielle Konflikte mit anderen Erweiterungsvertragsnamen zu vermeiden.

Sie können mehrere Hosts und mehrere Erweiterungen in derselben App definieren. In diesem Beispiel deklarieren wir einen Host. Die Erweiterung wird in einer anderen App definiert.

Deklarieren einer App als Erweiterung

Eine App identifiziert sich selbst als App-Erweiterung, indem das <uap3:AppExtension>-Element in der Datei "Package.appxmanifest" deklariert wird. Öffnen Sie die datei Package.appxmanifest im MathExtension Projekt, um zu sehen, wie dies geschieht.

Package.appxmanifest im MathExtension-Projekt:

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

Beachten Sie auch hier die xmlns:uap3="http://..." Zeile und das Vorhandensein von uap3 in IgnorableNamespaces. Diese sind erforderlich, da wir den uap3 Namespace verwenden.

<uap3:Extension Category="windows.appExtension"> identifiziert diese App als Erweiterung.

Die Bedeutung der <uap3:AppExtension>-Attribute lautet wie folgt:

<uap3:Properties> ist ein optionales Element, das benutzerdefinierte Metadaten enthält, die von Hostsystemen zur Laufzeit gelesen werden können. Im Codebeispiel wird die Erweiterung als App-Dienst implementiert, sodass der Host eine Möglichkeit benötigt, um den Namen dieses App-Diensts abzurufen, damit er ihn aufrufen kann. Der Name des App-Diensts wird im <Service>-Element festgelegt, das wir erstellt haben (wir hätten es nennen können, wie wir wollten). Der Host im Codebeispiel sucht zur Laufzeit nach dieser Eigenschaft, um den Namen des App-Diensts zu erfahren.

Entscheiden Sie, wie Sie die Erweiterung implementieren.

Die Build 2016-Sitzung zu App-Erweiterungen veranschaulicht die Verwendung des öffentlichen Ordners, der zwischen dem Host und den Erweiterungen gemeinsam genutzt wird. In diesem Beispiel wird die Erweiterung von einer JavaScript-Datei implementiert, die im öffentlichen Ordner gespeichert ist, den der Host aufruft. Dieser Ansatz hat den Vorteil, einfach zu sein, erfordert keine Kompilierung und kann das Erstellen der standardmäßigen Startseite unterstützen, die Anweisungen für die Erweiterung und einen Link zur Microsoft Store-Seite der Host-App bereitstellt. Weitere Informationen finden Sie im Build 2016-Codebeispiel zur App-Erweiterung. Siehe insbesondere das InvertImageExtension Projekt und InvokeLoad() in ExtensionManager.cs im ExtensibilitySample Projekt.

In diesem Beispiel verwenden wir einen App-Dienst, um die Erweiterung zu implementieren. App-Dienste haben die folgenden Vorteile:

• Wenn die Erweiterung abstürzt, wird die Host-App nicht beeinträchtigt, da sie in einem eigenen Prozess ausgeführt wird.
• Sie können die Sprache Ihrer Wahl verwenden, um den Dienst zu implementieren. Es muss nicht mit der Sprache übereinstimmen, die zum Implementieren der Host-App verwendet wird.
• Der App-Dienst hat Zugriff auf einen eigenen App-Container – der möglicherweise unterschiedliche Funktionen aufweist als der Host.
• Es gibt eine Isolation zwischen Daten im Dienst und der Host-App.

Host-App-Dienstcode

Hier ist der Hostcode, der den App-Dienst der Erweiterung aufruft:

ExtensionManager.cs im MathExtensionHost-Projekt

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
}

Dies ist typischer Code zum Aufrufen eines App-Diensts. Ausführliche Informationen zum Implementieren und Aufrufen eines App-Diensts finden Sie unter Erstellen und Nutzen eines App-Diensts.

Beachten Sie, wie der Name des zu rufenden App-Dienstes bestimmt wird. Da der Host keine Informationen über die Implementierung der Erweiterung hat, muss die Erweiterung den Namen ihres App-Dienstes angeben. Im Codebeispiel deklariert die Erweiterung den Namen des App-Service im <uap3:Properties>-Element der Datei.

Package.appxmanifest im MathExtension-Projekt

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

Sie können ihre eigene XML im <uap3:Properties>-Element definieren. In diesem Fall definieren wir den Namen des App-Diensts, damit der Host darauf zugreifen kann, wenn er die Erweiterung aufruft.

Wenn der Host eine Erweiterung lädt, extrahiert Code wie hier den Namen des Diensts aus den Eigenschaften, die im Package.appxmanifest der Erweiterung definiert sind:

Update() in ExtensionManager.cs im MathExtensionHost-Projekt

...
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

Mit dem in _serviceNamegespeicherten Namen des App-Service kann der Host diesen verwenden, um den App-Service aufzurufen.

Das Aufrufen eines App-Diensts erfordert auch den Familiennamen des Pakets, das den App-Dienst enthält. Glücklicherweise stellt die App-Erweiterungs-API diese Informationen bereit, die in der Zeile abgerufen werden: connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;

Definieren, wie der Host und die Erweiterung kommunizieren

App-Dienste verwenden ein ValueSet-, um Informationen auszutauschen. Als Autor des Hosts müssen Sie ein Protokoll für die Kommunikation mit Erweiterungen entwickeln, das flexibel ist. Im Codebeispiel bedeutet dies, dass Erweiterungen berücksichtigt werden, die in Zukunft 1, 2 oder mehr Argumente annehmen können.

In diesem Beispiel ist das Protokoll für die Argumente ein ValueSet-, das die Schlüsselwertpaare mit dem Namen "Arg" + der Argumentnummer enthält, z. B. Arg1 und Arg2. Der Host übergibt alle Argumente im ValueSet-, und die Erweiterung nutzt diejenigen, die sie benötigt. Wenn die Erweiterung ein Ergebnis berechnen kann, erwartet der Host, dass das von der Erweiterung zurückgegebene -ValueSet- einen Schlüssel mit dem Namen Result hat, der den Wert der Berechnung enthält. Wenn dieser Schlüssel nicht vorhanden ist, geht der Host davon aus, dass die Erweiterung die Berechnung nicht abschließen konnte.

Erweiterungs-App-Dienstcode

Im Codebeispiel wird der App-Dienst der Erweiterung nicht als Hintergrundaufgabe implementiert. Stattdessen wird das einzelne Proc-App-Dienstmodell verwendet, in dem der App-Dienst im selben Prozess ausgeführt wird wie die Erweiterungs-App, die sie hostt. Dies ist immer noch ein anderer Prozess als die Host-App, was die Vorteile der Prozesstrennung bietet, während einige Leistungsvorteile erzielt werden, indem die prozessübergreifende Kommunikation zwischen dem Erweiterungsprozess und dem Hintergrundprozess vermieden wird, der den App-Dienst implementiert. Siehe Konvertieren eines App-Dienstes, sodass er im selben Prozess wie die Host-App läuft, um den Unterschied zwischen einem App-Dienst, der als Hintergrundaufgabe läuft, und einem, der im selben Prozess läuft, zu verstehen.

Das System wechselt zu OnBackgroundActivate(), wenn der Anwendungsdienst aktiviert wird. Dieser Code richtet Ereignishandler ein, um den tatsächlichen App-Dienstaufruf zu behandeln, wenn er eintritt (OnAppServiceRequestReceived()), und um administrative Ereignisse zu verwalten, wie das Abrufen eines Verzögerungsobjekts, das die Bearbeitung bei Abbruch oder Schließen unterstützt.

App.xaml.cs im MathExtension-Projekt.

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;
    }
}

Der Code, der die Arbeit der Erweiterung ausführt, befindet sich in OnAppServiceRequestReceived(). Diese Funktion wird aufgerufen, wenn der App-Dienst aufgerufen wird, um eine Berechnung auszuführen. Es extrahiert die benötigten Werte aus dem ValueSet. Wenn die Berechnung ausgeführt werden kann, wird das Ergebnis unter einem Schlüssel namens Resultin der ValueSet- platziert, die an den Host zurückgegeben wird. Erinnere dich daran, dass gemäß dem Protokoll, wie dieser Host und seine Erweiterungen miteinander kommunizieren, das Vorhandensein eines "Result"-Schlüssels auf Erfolg hinweist; andernfalls auf Misserfolg.

App.xaml.cs im MathExtension-Projekt.

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();
}

Verwalten von Erweiterungen

Nachdem wir nun gesehen haben, wie die Beziehung zwischen einem Host und seinen Erweiterungen implementiert wird, sehen wir uns an, wie ein Host Erweiterungen findet, die auf dem System installiert sind, und reagiert auf das Hinzufügen und Entfernen von Paketen, die Erweiterungen enthalten.

Der Microsoft Store stellt Erweiterungen als Pakete bereit. Die AppExtensionCatalog findet installierte Pakete, die Erweiterungen enthalten, die dem Namen des Erweiterungsvertrags des Hosts entsprechen, und stellt Ereignisse bereit, die ausgelöst werden, wenn ein für den Host relevantes App-Erweiterungspaket installiert oder entfernt wird.

Im Codebeispiel verwaltet die ExtensionManager-Klasse (definiert in ExtensionManager.cs im MathExtensionHost Projekt) die Logik zum Laden von Erweiterungen und reagiert auf Installationen und Deinstallationen von Erweiterungspaketen.

Der ExtensionManager-Konstruktor verwendet die AppExtensionCatalog, um die App-Erweiterungen auf dem System zu finden, die denselben Erweiterungsvertragsnamen wie der Host haben:

ExtensionManager.cs im MathExtensionHost-Projekt.

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

Wenn ein Erweiterungspaket installiert ist, sammelt die ExtensionManager Informationen zu den Erweiterungen im Paket, die denselben Erweiterungsvertragsnamen wie der Host aufweisen. Eine Installation kann ein Update darstellen, in welchem Fall die Informationen der betroffenen Erweiterung aktualisiert werden. Wenn ein Erweiterungspaket deinstalliert wird, entfernt die ExtensionManager Informationen zu den betroffenen Erweiterungen, damit der Benutzer weiß, welche Erweiterungen nicht mehr verfügbar sind.

Die Extension-Klasse (definiert in ExtensionManager.cs im MathExtensionHost--Projekt) wurde für das Codebeispiel erstellt, um auf die ID, die Beschreibung, das Logo und die app-spezifischen Informationen zuzugreifen, z. B. ob der Nutzer die Erweiterung aktiviert hat.

Um zu sagen, dass die Erweiterung geladen ist (siehe Load() in ExtensionManager.cs), bedeutet es, dass der Paketstatus einwandfrei ist und dass wir die ID, das Logo, die Beschreibung und den öffentlichen Ordner erhalten haben (den wir in diesem Beispiel nicht verwenden, sondern nur zeigen, wie man ihn erhält). Das Erweiterungspaket selbst wird nicht geladen.

Das Konzept der Entladung wird verwendet, um nachzuverfolgen, welche Erweiterungen dem Benutzer nicht mehr präsentiert werden sollen.

Die ExtensionManager stellt eine Sammlung von Extension Instanzen bereit, damit die Erweiterungen mit ihren Namen, Beschreibungen und Logos datengebunden an die Benutzeroberfläche gebunden werden können. Die ExtensionsTab--Seite bindet diese Sammlung ein und stellt die UI zum Aktivieren/Deaktivieren von Erweiterungen und zum Entfernen bereit.

Wenn eine Erweiterung entfernt wird, fordert das System den Benutzer auf, zu überprüfen, ob er das Paket deinstallieren möchte, das die Erweiterung enthält (und möglicherweise andere Erweiterungen enthält). Wenn der Benutzer zustimmt, wird das Paket deinstalliert, und die ExtensionManager entfernt die Erweiterungen im deinstallierten Paket aus der Liste der Erweiterungen, die für die Host-App verfügbar sind.

UI deinstallieren

Debuggen von App-Erweiterungen und Hosts

Häufig sind der Erweiterungshost und die Erweiterung nicht Teil derselben Lösung. In diesem Fall debuggen Sie den Host und die Erweiterung:

1. Laden Sie Ihr Hostprojekt in einer Instanz von Visual Studio.
2. Laden Sie Ihre Erweiterung in einer anderen Instanz von Visual Studio.
3. Starten Sie Ihre Host-App im Debugger.
4. Starten Sie die Erweiterungs-App im Debugger. (Wenn Sie die Erweiterung bereitstellen möchten, anstatt sie zu debuggen, führen Sie Build > Deploy Solutionaus, um stattdessen das Paketinstallationsereignis des Hosts zu testen.)

Jetzt können Sie Haltepunkte im Host und der Erweiterung erreichen. Wenn Sie mit dem Debuggen der Erweiterungs-App selbst beginnen, wird ein leeres Fenster für die App angezeigt. Wenn Sie das leere Fenster nicht sehen möchten, können Sie die Debugeinstellungen für das Erweiterungsprojekt ändern, um die App nicht zu starten, sondern den Code zu debuggen, wenn er gestartet wird (klicken Sie mit der rechten Maustaste auf das Erweiterungsprojekt, Eigenschaften>Debuggen> auswählen, Nicht starten, sondern meinen Code debuggen, wenn er gestartet wird). Sie müssen trotzdem das Debuggen des Erweiterungsprojekts starten (F5), aber es bleibt im Wartezustand, bis der Host die Erweiterung aktiviert, und dann werden Ihre Haltepunkte in der Erweiterung erreicht.

Debuggen des Codebeispiels

Im Codebeispiel befinden sich der Host und die Erweiterung in derselben Lösung. Gehen Sie wie folgt vor, um das Debuggen auszuführen:

1. Stellen Sie sicher, dass MathExtensionHost- das Startprojekt ist (klicken Sie mit der rechten Maustaste auf das MathExtensionHost- Projekt, klicken Sie auf Als Startprojekt festlegen).
2. Setzen Sie im Projekt Invoke einen Haltepunkt auf in ExtensionManager.cs.
3. F5 zum Ausführen des MathExtensionHost Projekts.
4. Setzen Sie im OnAppServiceRequestReceived Projekt einen Haltepunkt in App.xaml.cs auf .
5. Beginnen Sie mit dem Debuggen des MathExtension--Projekts (klicken Sie mit der rechten Maustaste auf das MathExtension--Projekt, wählen Sie Debuggen und > neue Instanzstarten), wodurch das Projekt bereitgestellt wird und das Paketinstallationsereignis im Host ausgelöst wird.
6. Navigieren Sie in der MathExtensionHost-App zur Seite Berechnung und klicken Sie auf x^y, um die Erweiterung zu aktivieren. Der Invoke() Haltepunkt wird zuerst erreicht, und Sie können sehen, dass der Aufruf des Erweiterungs-App-Dienstes gemacht wird. Anschließend wird die OnAppServiceRequestReceived() Methode in der Erweiterung aufgerufen, und Sie können sehen, dass der App-Service das Ergebnis berechnet und zurückgibt.

Fehlerbehebungs-Erweiterungen, die als App-Dienst implementiert sind

Wenn Ihr Erweiterungshost Probleme hat, eine Verbindung mit dem App-Dienst für Ihre Erweiterung herzustellen, stellen Sie sicher, dass das <uap:AppService Name="...">-Attribut dem entspricht, was Sie in Ihrem <Service>-Element angegeben haben. Wenn sie nicht übereinstimmen, stimmt der Dienstname, den Ihre Erweiterung bereitstellt, nicht mit dem app-Dienstnamen überein, den Sie implementiert haben, und der Host kann Ihre Erweiterung nicht aktivieren.

Package.appxmanifest im MathExtension-Projekt:

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

Eine Checkliste von grundlegenden Szenarien zum Testen

Wenn Sie einen Erweiterungshost erstellen und bereit sind, zu testen, wie gut erweiterungen unterstützt werden, sind hier einige grundlegende Szenarien, die Sie ausprobieren können:

• Führen Sie den Host aus, und stellen Sie dann eine Erweiterungsanwendung bereit.
  • Nimmt der Host während der Ausführung neue Erweiterungen auf, die hinzukommen?
• Stellen Sie die Erweiterungs-App bereit, und stellen Sie den Host bereit, und führen Sie sie aus.
  • Nimmt der Host bereits vorhandene Erweiterungen auf?
• Führen Sie den Host aus, und entfernen Sie dann die Erweiterungs-App.
  • Erkennt der Host die Entfernung korrekt?
• Führen Sie den Host aus, und aktualisieren Sie dann die Erweiterungs-App auf eine neuere Version.
  • Nimmt der Host die Änderung auf und entlädt die alten Versionen der Erweiterung ordnungsgemäß?

Fortgeschrittene Szenarien zum Testen:

• Führen Sie den Host aus, verschieben Sie die Erweiterungs-App auf ein Wechselmedium, entfernen Sie das Medium
  • Erkennt der Host die Änderung im Paketstatus und deaktiviert die Erweiterung?
• Führen Sie den Host aus, und beschädigen Sie dann die Erweiterungs-App (machen Sie sie ungültig, unterschreiben Sie sie anders, usw.)
  • Erkennt der Host die manipulierte Erweiterung und behandelt sie ordnungsgemäß?
• Führen Sie den Host aus, und stellen Sie dann eine Erweiterungs-App mit ungültigen Inhalten oder Eigenschaften bereit.
  • Erkennt der Host ungültige Inhalte und behandelt ihn ordnungsgemäß?

Entwurfsüberlegungen

• Stellen Sie eine Benutzeroberfläche bereit, die dem Benutzer anzeigt, welche Erweiterungen verfügbar sind, und ermöglicht es ihnen, sie zu aktivieren/zu deaktivieren. Möglicherweise können Sie auch Glyphen für Erweiterungen hinzufügen, die nicht mehr verfügbar sind, da ein Paket offline geht usw.
• Leiten Sie den Benutzer an die Stelle, an der er Erweiterungen erhalten kann. Möglicherweise kann Ihre Erweiterungsseite eine Microsoft Store-Suchabfrage bereitstellen, die eine Liste der Erweiterungen anzeigt, die mit Ihrer App verwendet werden können.
• Überlegen Sie, wie Sie den Benutzer über das Hinzufügen und Entfernen von Erweiterungen informieren. Möglicherweise erstellen Sie eine Benachrichtigung darüber, wann eine neue Erweiterung installiert ist, und laden Sie den Benutzer ein, sie zu aktivieren. Erweiterungen sollten standardmäßig deaktiviert werden, damit Benutzer die Kontrolle behalten.

Unterschiede zwischen App-Erweiterungen und optionalen Paketen

Der wichtigste Unterschied zwischen optionalen Paketen und App-Erweiterungen ist offenes Ökosystem im Vergleich zu geschlossenem Ökosystem und abhängiges Paket im Vergleich zu unabhängigem Paket.

App-Erweiterungen nehmen an einem offenen Ökosystem teil. Wenn Ihre App App-Erweiterungen hosten kann, kann jeder eine Erweiterung für Ihren Host schreiben, solange sie Ihre Methode zum Übergeben/Empfangen von Informationen aus der Erweiterung einhalten. Dies unterscheidet sich von optionalen Paketen, die an einem geschlossenen Ökosystem teilnehmen, in dem der Herausgeber entscheidet, wer ein optionales Paket erstellen darf, das mit der App verwendet werden kann.

App-Erweiterungen sind unabhängige Pakete und können eigenständige Apps sein. Sie können keine Bereitstellungsabhängigkeit von einer anderen App haben. Optionale Pakete erfordern das primäre Paket und können nicht ohne das Paket ausgeführt werden.

Ein Erweiterungspaket für ein Spiel wäre ein guter Kandidat für ein optionales Paket, da es eng an das Spiel gebunden ist, es kann nicht unabhängig vom Spiel ausgeführt werden, und Sie möchten möglicherweise nicht, dass Erweiterungspakete nur von jedem Entwickler im Ökosystem erstellt werden.

Wenn dasselbe Spiel anpassbare UI-Add-Ons oder Designs hatte, kann eine App-Erweiterung eine gute Wahl sein, da die App, die die Erweiterung bereitstellt, eigenständig ausgeführt werden kann und jeder Drittanbieter sie erstellen könnte.

Bemerkungen

Dieses Thema enthält eine Einführung in App-Erweiterungen. Die wichtigsten Punkte, die Sie beachten müssen, sind die Erstellung des Hosts und dessen Markierung in der Datei "Package.appxmanifest", sowie das Erstellen der Erweiterung und deren Markierung ebenfalls in der "Package.appxmanifest"-Datei. Es muss bestimmt werden, wie die Erweiterung implementiert werden soll, z.B. als App-Dienst, Hintergrundaufgabe oder auf andere Weise. Es wird definiert, wie der Host mit den Erweiterungen kommunizieren wird, und es wird die AppExtensions-API verwendet, um auf die Erweiterungen zuzugreifen und diese zu verwalten.

Zugehörige Themen

• Einführung in App-Erweiterungen
• Build 2016-Sitzung zu App-Erweiterungen
• Codebeispiel für die Build 2016-App-Erweiterung
• Unterstützen Sie Ihre App mit Hintergrundaufgaben
• Erstellen und Nutzen eines App-Diensts.
• AppExtensions-Namespace
• Erweitern Sie Ihre App mit Diensten, Erweiterungen und Paketen