Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Questo articolo illustra come creare un'estensione dell'app di Windows 10 e ospitarla in un'app. Le estensioni dell'app sono supportate nelle app UWP e app desktop impacchettate.
Per illustrare come creare un'estensione dell'app, questo articolo usa il codice XML del manifesto del pacchetto e i frammenti di codice dell'esempio di codice dell'estensione matematica. Questo esempio è un'app UWP, ma le funzionalità illustrate nell'esempio sono applicabili anche alle app desktop in pacchetto. Seguire queste istruzioni per iniziare a usare l'esempio:
- Scaricare e decomprimere l'esempio di codice dell'estensione matematica .
- Apri MathExtensionSample.sln in Visual Studio 2019. Impostare il tipo di compilazione su x86 (Build>Configuration Manager, quindi impostare Platform su x86 per entrambi i progetti).
- Distribuire la soluzione: Compila>Distribuisci Soluzione.
Introduzione alle estensioni dell'app
In Windows 10, le estensioni delle app offrono funzionalità simili ai plug-in e ai componenti aggiuntivi sulle altre piattaforme. Le estensioni dell'app sono state introdotte nell'edizione dell'anniversario di Windows 10 (versione 1607, build 10.0.14393).
Le estensioni dell'app sono app UWP o app desktop pacchettizzate con una dichiarazione di estensione che consente loro di condividere contenuti e eventi di distribuzione con un'app ospite. Un'app di estensione può fornire più estensioni.
Poiché le estensioni delle app sono solo app UWP o app desktop in pacchetto, possono anche essere app completamente funzionali, estensioni host e fornire estensioni ad altre app, senza creare pacchetti di app separati.
Quando crei un host di estensione dell'applicazione, crei un'opportunità per sviluppare un ecosistema attorno alla tua app nel quale altri sviluppatori possono migliorare la tua app in modi che potresti non aver previsto o per cui potresti non avere le risorse. Prendere in considerazione le estensioni di Microsoft Office, le estensioni di Visual Studio, le estensioni del browser e così via. Questi creano esperienze più avanzate per le app che vanno oltre le funzionalità fornite. Le estensioni possono aggiungere valore e longevità all'app.
A livello generale, per configurare una relazione di estensione dell'app, è necessario:
- Dichiarare un'applicazione come host per le estensioni.
- Dichiarare un'applicazione estensione.
- Decidere se implementare l'estensione come servizio app, attività in background o altro.
- Definire il modo in cui gli host e le relative estensioni comunicheranno.
- Usare l'API Windows.ApplicationModel.AppExtensions nell'app host per accedere alle estensioni.
Vediamo come questa operazione viene eseguita esaminando l'esempio di codice dell'estensione matematica che implementa una calcolatrice ipotetica a cui è possibile aggiungere nuove funzioni usando le estensioni. In Microsoft Visual Studio 2019 caricare MathExtensionSample.sln dall'esempio di codice.
Dichiarare un'app quale host di estensione
Un'app si identifica come host di estensione dell'app dichiarando l'elemento <AppExtensionHost> nel file Package.appxmanifest. Vedere il file di
Package.appxmanifest nel progetto 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>
Si notino il xmlns:uap3="http://..." e la presenza di uap3 in IgnorableNamespaces. Questi sono necessari perché si usa lo spazio dei nomi uap3.
<uap3:Extension Category="windows.appExtensionHost"> identifica questa app come host di estensione.
L'elemento Nome in <uap3:AppExtensionHost> è il nome del contratto di estensione . Quando un'estensione specifica lo stesso nome del contratto di estensione, l'host sarà in grado di trovarlo. Per convenzione, è consigliabile creare il nome del contratto di estensione usando l'app o il nome dell'editore per evitare potenziali conflitti con altri nomi di contratto di estensione.
È possibile definire più host e più estensioni nella stessa app. In questo esempio viene dichiarato un host. L'estensione è definita in un'altra app.
Dichiarare un'app essere estensione
Un'applicazione si identifica come estensione di un'applicazione dichiarando l'elemento <uap3:AppExtension> nel proprio file Package.appxmanifest. Apri il file Package.appxmanifest nel progetto MathExtension per vedere come viene eseguita questa operazione.
Package.appxmanifest nel progetto 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>
Anche in questo caso, notare la xmlns:uap3="http://..." riga e la presenza di uap3 in IgnorableNamespaces. Queste sono necessarie perché stiamo utilizzando lo uap3 spazio dei nomi.
<uap3:Extension Category="windows.appExtension"> identifica questa app come estensione.
Il significato degli <uap3:AppExtension> attributi è il seguente:
<uap3:Properties> è un elemento facoltativo che contiene metadati personalizzati che gli host possono leggere in fase di esecuzione. Nell'esempio di codice, l'estensione viene implementata come servizio app in modo che l'host richieda un modo per ottenere il nome del servizio app in modo che possa chiamarlo. Il nome del servizio app è definito nell'elemento <del servizio>, che abbiamo definito (avremmo potuto chiamarlo in qualsiasi modo desiderassimo). L'host nell'esempio di codice cerca questa proprietà in fase di esecuzione per apprendere il nome del servizio app.
Decidere come implementare l'estensione.
La sessione Build 2016 sulle estensioni dell'app illustra come usare la cartella pubblica condivisa tra l'host e le estensioni. In questo esempio, l'estensione viene implementata da un file JavaScript archiviato nella cartella pubblica, che l'host richiama. Questo approccio ha il vantaggio di essere leggero, non richiede la compilazione e può supportare la creazione della pagina di destinazione predefinita che fornisce istruzioni per l'estensione e un collegamento alla pagina di Microsoft Store dell'app host. Per informazioni dettagliate, vedere l'esempio di codice dell'estensione dell'app build 2016. In particolare, vedere il progetto
In questo esempio si userà un servizio app per implementare l'estensione. I servizi app presentano i vantaggi seguenti:
- Se l'estensione si blocca, l'app host non verrà chiusa perché è eseguita in un proprio processo.
- È possibile usare il linguaggio preferito per implementare il servizio. Non deve corrispondere alla lingua usata per implementare l'app host.
- Il servizio app ha accesso al proprio contenitore di app, che può avere funzionalità diverse rispetto all'host.
- Esiste un isolamento tra i dati nel servizio e l'app host.
Codice del servizio app host
Ecco il codice host che richiama il servizio app dell'estensione:
ExtensionManager.cs nel progetto 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
}
Questo è il codice tipico per richiamare un servizio app. Per informazioni dettagliate su come implementare e chiamare un servizio app, vedere Come creare e usare un servizio app.
Un aspetto da notare è il modo in cui viene determinato il nome del servizio app da chiamare. Poiché l'host non dispone di informazioni sull'implementazione dell'estensione, l'estensione deve fornire il nome del servizio dell'applicazione. Nell'esempio di codice, l'estensione dichiara il nome del servizio app nel suo file nell'elemento <uap3:Properties>:
Package.appxmanifest nel progetto MathExtension
...
<uap3:Extension Category="windows.appExtension">
<uap3:AppExtension ...>
<uap3:Properties>
<Service>com.microsoft.powservice</Service>
</uap3:Properties>
</uap3:AppExtension>
</uap3:Extension>
È possibile definire il proprio codice XML nell'elemento <uap3:Properties> . In questo caso, definiamo il nome del servizio applicativo affinché l'host possa utilizzarlo quando invoca l'estensione.
Quando l'host carica un'estensione, il codice seguente estrae il nome del servizio dalle proprietà definite nell'estensione Package.appxmanifest:
Update() in ExtensionManager.cs, nel progetto 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
Con il nome del servizio app archiviato in _serviceName, l'host è in grado di usarlo per richiamare il servizio app.
Per chiamare un servizio app è necessario anche il nome della famiglia del pacchetto che contiene il servizio app. Fortunatamente, l'API dell'estensione dell'app fornisce queste informazioni ottenute nella riga: connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;
Definire il modo in cui l'host e l'estensione comunicheranno
I servizi delle app usano un ValueSet per scambiare informazioni. In qualità di autore dell'host, è necessario sviluppare un protocollo flessibile per comunicare con le estensioni. Nell'esempio di codice ciò significa tenere conto delle estensioni che possono richiedere 1, 2 o più argomenti in futuro.
Per questo esempio, il protocollo per gli argomenti è un ValueSet contenente le coppie chiave-valore denominate 'Arg' + il numero di argomento, Arg1 ad esempio e Arg2. L'host passa tutti gli argomenti nel ValueSet, e l'estensione usa quelli di cui ha bisogno. Se l'estensione è in grado di calcolare un risultato, l'host si aspetta che la ValueSet sia restituita dall'estensione e abbia una chiave denominata Result che contenga il valore del calcolo. Se tale chiave non è presente, l'host presuppone che l'estensione non sia riuscita a completare il calcolo.
Codice del servizio app di estensione
Nell'esempio di codice il servizio app dell'estensione non viene implementato come attività in background. Utilizza invece il modello di servizio applicativo a processo singolo, in cui il servizio applicativo viene eseguito nello stesso processo dell'applicazione di estensione che lo ospita. Questo è ancora un processo diverso rispetto all'app host, offrendo i vantaggi della separazione dei processi operativi, ottenendo alcuni vantaggi prestazionali evitando la comunicazione interprocesso tra il processo di estensione e il processo in background che implementa il servizio app. Consultare Convertire un servizio app per l'esecuzione nello stesso processo dell'app host per capire la differenza tra un servizio app eseguito come attività in background e uno eseguito nello stesso processo.
Il sistema esegue l'operazione OnBackgroundActivate() quando viene attivato il servizio app. Tale codice configura i gestori eventi per gestire la chiamata del servizio app reale quando viene (OnAppServiceRequestReceived()) e gestire gli eventi di manutenzione, ad esempio ottenere un oggetto deferimento che gestisce un evento di annullamento o di chiusura.
App.xaml.cs nel progetto 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;
}
}
Il codice che esegue il lavoro dell'estensione è in OnAppServiceRequestReceived(). Questa funzione viene chiamata quando viene richiamato il servizio app per eseguire un calcolo. Estrae i valori necessari da ValueSet. Se può eseguire il calcolo, inserisce il risultato sotto una chiave denominata Resultnel ValueSet che viene restituito all'host. Tenere presente che, in base al protocollo definito per il modo in cui l'host e le relative estensioni comunicheranno, la presenza di una chiave di risultato indicherà l'esito positivo; altrimenti fallimento.
App.xaml.cs nel progetto 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();
}
Gestire le estensioni
Ora che abbiamo visto come implementare la relazione tra un host e le relative estensioni, vediamo come un host trova le estensioni installate nel sistema e reagisce all'aggiunta e alla rimozione di pacchetti contenenti estensioni.
Microsoft Store offre estensioni come pacchetti. AppExtensionCatalog trova i pacchetti installati che contengono estensioni corrispondenti al nome del contratto di estensione dell'host e fornisce eventi che vengono generati quando viene installato o rimosso un pacchetto di estensione dell'app rilevante per l'host.
Nell'esempio di codice la ExtensionManager classe (definita in ExtensionManager.cs nel progetto MathExtensionHost ) esegue il wrapping della logica per caricare le estensioni e rispondere alle installazioni e alle disinstallazioni dei pacchetti di estensione.
Il costruttore di ExtensionManager utilizza AppExtensionCatalog per trovare le estensioni dell'app sul sistema che hanno lo stesso nome del contratto di estensione dell'host.
ExtensionManager.cs nel progetto MathExtensionHost.
public ExtensionManager(string extensionContractName)
{
// catalog & contract
ExtensionContractName = extensionContractName;
_catalog = AppExtensionCatalog.Open(ExtensionContractName);
...
}
Quando viene installato un pacchetto di estensione, il ExtensionManager raccoglie informazioni sulle estensioni in quel pacchetto che hanno lo stesso nome di contratto di estensione dell'host. Un'installazione può rappresentare un aggiornamento nel qual caso le informazioni sull'estensione interessata vengono aggiornate. Quando un pacchetto di estensione viene disinstallato, ExtensionManager rimuove le informazioni sulle estensioni interessate in modo che l'utente conosca quali estensioni non sono più disponibili.
La classe Extension (definita in ExtensionManager.cs nel progetto MathExtensionHost) è stata creata per l'esempio di codice per accedere all'ID, alla descrizione, al logo e alle informazioni specifiche dell'app di un'estensione, come il fatto che l'utente abbia abilitato l'estensione.
Per dire che l'estensione è caricata (vedere Load() in ExtensionManager.cs) significa che lo stato del pacchetto va bene e che è stato ottenuto il relativo ID, logo, descrizione e cartella pubblica (che non viene usata in questo esempio - è solo per mostrare come ottenerla). Il pacchetto di estensione stesso non viene caricato.
Il concetto di scaricamento viene usato per tenere traccia delle estensioni che non devono più essere presentate all'utente.
Il ExtensionManager fornisce una raccolta Extension istanze in modo che le estensioni, i relativi nomi, descrizioni e logo possano essere associati all'interfaccia utente. La pagina ExtensionsTab viene associata a questa raccolta e fornisce l'interfaccia utente per abilitare/disabilitare le estensioni e rimuoverle.
Quando un'estensione viene rimossa, il sistema chiede all'utente di verificare che voglia disinstallare il pacchetto che contiene l'estensione (e possibilmente contiene altre estensioni). Se l'utente accetta, il pacchetto viene disinstallato e ExtensionManager rimuove le estensioni nel pacchetto disinstallato dall'elenco di estensioni disponibili per l'app host.
Debug di estensioni e host dell'app
Spesso, l'host di estensione e l'estensione non fanno parte della stessa soluzione. In tal caso, per eseguire il debug dell'host e dell'estensione:
- Carica il tuo progetto host in un'istanza di Visual Studio.
- Caricare l'estensione in un'altra istanza di Visual Studio.
- Avvia l'app host nel debugger.
- Avviare l'app di estensione nel debugger. Se si vuole distribuire l'estensione, anziché eseguirne il debug, per testare l'evento di installazione del pacchetto dell'host, eseguire invece Build > Deploy Solution.
A questo punto sarà possibile raggiungere i punti di interruzione nell'host e nell'estensione. Se si avvia il debug dell'app di estensione stessa, verrà visualizzata una finestra vuota per l'app. Se non si vuole visualizzare la finestra vuota, è possibile modificare le impostazioni di debug del progetto di estensione in modo da non avviare l'app, ma eseguirne il debug all'avvio (fare clic con il pulsante destro del mouse sul progetto di estensione, Proprietà>Debug>, quindi selezionare Non avviare, ma eseguire il debug del codice all'avvio). È comunque necessario avviare il debug (F5) del progetto di estensione. L'estensione attenderà fino a quando l'host attiverà l'estensione stessa e i punti di interruzione nell'estensione verranno raggiunti.
Eseguire il debug dell'esempio di codice
Nell'esempio di codice l'host e l'estensione si trovano nella stessa soluzione. Eseguire le operazioni seguenti per eseguire il debug:
- Assicurarsi che MathExtensionHost sia il progetto di avvio (fare clic con il pulsante destro del mouse sul progetto MathExtensionHost, fare clic su Imposta come progetto di avvio).
- Inserire un punto di interruzione in
Invokein ExtensionManager.cs nel progetto MathExtensionHost. - F5 per eseguire il progetto MathExtensionHost.
- Inserire un punto di interruzione su
OnAppServiceRequestReceivedin App.xaml.cs nel progetto MathExtension. - Avviare il debug del progetto MathExtension
(fare clic con il pulsante destro del mouse sul progetto MathExtension , Debug ) che lo distribuirà e attiverà l'evento di installazione del pacchetto nell'host.Avvia nuova istanza - Nell'app MathExtensionHost, passare alla pagina Calcolo e fare clic su x^y per attivare l'estensione. Il punto di interruzione
Invoke()viene raggiunto per primo ed è possibile vedere la chiamata al servizio delle estensioni in corso. Viene quindi raggiunto il metodoOnAppServiceRequestReceived()nell'estensione, e il servizio dell'app calcola il risultato e lo restituisce.
Risoluzione dei problemi delle estensioni implementate come servizio applicativo
Se l'host dell'estensione presenta problemi di connessione al servizio applicativo per l'estensione, assicurati che l'attributo <uap:AppService Name="..."> corrisponda a ciò che hai inserito nell'elemento <Service>. Se non corrispondono, il nome del servizio fornito dall'estensione non corrisponderà al nome del servizio app implementato e l'host non sarà in grado di attivare l'estensione.
Package.appxmanifest nel progetto 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>
Elenco di controllo degli scenari di base da testare
Quando si compila un host di estensione e si è pronti a testare il livello di supporto delle estensioni, ecco alcuni scenari di base da provare:
- Esegui l'host e poi implementa un'app di estensione
- L'host rileva nuove estensioni che si presentano mentre è in esecuzione?
- Implementare l'applicazione di estensione e quindi implementare ed eseguire l'host.
- L'host riconosce le estensioni precedenti?
- Esegui l'host e poi rimuovi l'applicazione di estensione.
- L'host rileva correttamente la rimozione?
- Eseguire l'host e quindi aggiornare l'app di estensione a una versione più recente.
- L'host preleva la modifica e scarica correttamente le versioni precedenti dell'estensione?
Scenari avanzati da testare:
- Avviare l'host, spostare l'applicazione di estensione sul supporto rimovibile, rimuovere il supporto
- L'host rileva la modifica dello stato del pacchetto e disabilita l'estensione?
- Eseguire l'host, quindi danneggiare l'app di estensione (renderla non valida, firmata in modo diverso e così via)
- L'host rileva l'estensione manomessa e la gestisce correttamente?
- Esegui l'host, quindi distribuisci un'app di estensione con contenuti o proprietà non validi.
- L'host rileva il contenuto non valido e lo gestisce correttamente?
Considerazioni sulla progettazione
- Fornire l'interfaccia utente che mostra l'utente quali estensioni sono disponibili e consente loro di abilitarle o disabilitarle. È anche possibile prendere in considerazione l'aggiunta di glifi per le estensioni non disponibili perché un pacchetto diventa offline, eccetera.
- Indirizzare l'utente alla posizione in cui possono ottenere le estensioni. Forse la pagina dell'estensione può fornire una query di ricerca di Microsoft Store che visualizza un elenco di estensioni che possono essere usate con la tua app.
- Si consideri come notificare all'utente l'aggiunta e la rimozione delle estensioni. È possibile creare una notifica per quando viene installata una nuova estensione e invitare l'utente ad abilitarla. Le estensioni devono essere disabilitate per impostazione predefinita in modo che gli utenti siano in controllo.
Differenze tra le estensioni dell'app e i pacchetti facoltativi
Il differenziatore principale tra i pacchetti facoltativi e e le estensioni dell'app sono l'ecosistema aperto rispetto all'ecosistema chiuso e il pacchetto dipendente rispetto al pacchetto indipendente.
Le estensioni dell'app partecipano a un ecosistema aperto. Se l'app può ospitare le estensioni dell'app, chiunque può scrivere un'estensione per l'host purché rispettino il metodo di passaggio/ricezione di informazioni dall'estensione. Ciò differisce dai pacchetti facoltativi che partecipano a un ecosistema chiuso in cui l'editore decide chi può creare un pacchetto facoltativo che può essere usato con l'app.
Le estensioni dell'app sono pacchetti indipendenti e possono essere app autonome. Non possono avere una dipendenza di distribuzione da un'altra app. I pacchetti facoltativi richiedono il pacchetto primario e non possono essere eseguiti senza di esso.
Un pacchetto di espansione per un gioco sarebbe un buon candidato per un pacchetto facoltativo perché è strettamente legato al gioco, non può essere eseguito indipendentemente dal gioco e potrebbe non volere che i pacchetti di espansione vengano creati da qualsiasi sviluppatore nell'ecosistema.
Se quello stesso gioco avesse componenti aggiuntivi o opzioni di personalizzazione dell'interfaccia utente, un'estensione dell'app potrebbe essere una buona scelta perché l'app che fornisce l'estensione potrebbe funzionare autonomamente e qualsiasi terza parte potrebbe crearli.
Osservazioni:
Questo argomento fornisce un'introduzione alle estensioni dell'app. Le cose chiave da notare sono la creazione dell'host e contrassegnarla come tale nel file Package.appxmanifest, creando l'estensione e contrassegnandola come tale nel file Package.appxmanifest, determinando come implementare l'estensione (ad esempio un servizio app, un'attività in background o altri mezzi), definendo come l'host comunicherà con le estensioni, e usando l'API AppExtensions per accedere e gestire le estensioni.
Argomenti correlati
- Introduzione alle estensioni dell'app
- Sessione Build 2016 sulle estensioni delle app
- esempio di codice dell'estensione dell'app Build 2016
- Alimenta la tua app con attività in background
- Come creare e utilizzare un servizio app.
- spazio dei nomi AppExtensions
- Estendere l'app con servizi, estensioni e pacchetti