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.
Nota
Alcune informazioni sono relative a un prodotto non definitivo, che potrebbe subire modifiche sostanziali prima del rilascio sul mercato. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Questo articolo illustra come creare un provider di feed semplice che registra un URI del contenuto del feed e implementa l'interfaccia IFeedProvider. I metodi di questa interfaccia vengono richiamati dalla scheda Widget per richiedere parametri di stringa di query personalizzati, in genere per supportare gli scenari di autenticazione. I provider di feed possono supportare un singolo feed o multipli feed.
Per implementare un provider di feed con C++/WinRT, vedere Implementare un provider di feed in un'app win32 (C++/WinRT).
Prerequisiti
- Il dispositivo deve avere la modalità sviluppatore abilitata. Per altre informazioni, vedere Abilitare il dispositivo per lo sviluppo.
- Visual Studio 2022 o versioni successive con il carico di lavoro Sviluppo per la piattaforma UWP (Universal Windows Platform).
Creare una nuova app console C#
In Visual Studio creare un nuovo progetto. Nella finestra di dialogo Creare un nuovo progetto impostare il filtro del linguaggio su "C#" e il filtro della piattaforma su Windows, quindi selezionare il modello di progetto App console. Assegnare il nome al nuovo progetto "ExampleFeedProvider". Per questa procedura dettagliata, assicurarsi che sia deselezionato Inserisci soluzione e progetto nella stessa directory. Quando richiesto, impostare la versione .NET di destinazione su 6.0.
Durante il caricamento del progetto, in Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto e selezionare Proprietà. Nella pagina Generale, scorrere verso il basso fino a Sistema operativo di destinazione e selezionare "Windows". In Versione del Sistema operativo di destinazione, selezionare la versione 10.022631.2787 o successiva.
Si noti che questa procedura dettagliata usa un'app console che visualizza la finestra della console quando il feed viene attivato per consentire un debug facilitato. Quando si è pronti per pubblicare l'app del provider di feed, è possibile convertire l'applicazione console in un'applicazione Windows seguendo la procedura descritta in Convertire l'app console in un'app di Windows.
Aggiungere riferimenti al pacchetto NuGet Windows App SDK
Questo esempio usa il pacchetto NuGet Windows App SDK stabile più recente. In Esplora soluzioni fare clic con il pulsante destro del mouse su Dipendenze e selezionare Gestisci pacchetti NuGet.... Nella gestione pacchetti NuGet, selezionare la scheda Sfoglia e cercare "Microsoft.WindowsAppSDK". Selezionare la versione stabile più recente nell'elenco a discesa Versione e quindi fare clic su Installa.
Aggiungere una classe FeedProvider per gestire le operazioni del feed
In Visual Studio, fare clic con il pulsante destro del mouse sul progetto ExampleFeedProvider in Esplora soluzioni e selezionare Aggiungi->Classe. Nella finestra di dialogo Aggiungi classe, assegnare alla classe il nome "FeedProvider" e fare clic su Aggiungi. Nel file FeedProvider.cs generato aggiornare la definizione della classe per indicare che implementa l'interfaccia IFeedProvider.
Creare un CLSID che verrà usato per identificare il provider di feed per l'attivazione COM. Generare un GUID in Visual Studio passando a Strumenti->Crea GUID. Salvare questo GUID in un file di testo da usare in un secondo momento, quando si crea il pacchetto dell'app del provider di feed. Sostituire il GUID nelle annotazioni per la classe FeedProvider illustrata nell'esempio seguente.
// FeedProvider.cs
using Microsoft.Windows.Widgets.Feeds.Providers;
...
[ComVisible(true)]
[ComDefaultInterface(typeof(IFeedProvider))]
[Guid("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")]
public sealed class FeedProvider : IFeedProvider
Implementare i metodi IFeedProvider
Nelle sezioni successive verranno implementati i metodi dell'interfaccia IFeedProvider.
Nota
Gli oggetti passati nei metodi di callback dell'interfaccia IFeedProvider sono garantiti solo per essere validi all'interno del callback. Non è consigliabile archiviare riferimenti a questi oggetti perché il relativo comportamento all'esterno del contesto del callback non è definito.
OnFeedProviderEnabled
Il metodo OnFeedProviderEnabled viene richiamato quando un feed associato al provider viene creato dall'host della scheda Widget. Nell'implementazione di questo metodo generare una stringa di query con i parametri che verranno passati all'URL che fornisce il contenuto del feed, inclusi i token di autenticazione necessari. Creare un'istanza di CustomQueryParametersUpdateOptions, passando in FeedProviderDefinitionId dagli argomenti dell'evento che identificano il feed abilitato e la stringa di query. Ottenere il FeedManager e chiamare SetCustomQueryParameters per registrare i parametri della stringa di query con la scheda Widget.
// FeedProvider.cs
public void OnFeedProviderEnabled(FeedProviderEnabledArgs args)
{
Console.WriteLine($"{args.FeedProviderDefinitionId} feed provider was enabled.");
var updateOptions = new CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId, "param1¶m2");
FeedManager.GetDefault().SetCustomQueryParameters(updateOptions);
}
OnFeedProviderDisabled
OnFeedProviderDisabled viene chiamato nella scheda Widget quando tutti i feed per questo provider sono stati disabilitati. I provider di feed non devono eseguire alcuna azione in risposta a questa chiamata al metodo. La chiamata al metodo può essere usata per scopi di telemetria o per aggiornare i parametri della stringa di query o revocare i token di autenticazione, se necessario. Se l'app supporta solo un singolo provider di feed o se tutti i provider di feed supportati dall'app sono stati disabilitati, l'app può uscire in risposta a questo callback.
// FeedProvider.cs
public void OnFeedProviderDisabled(FeedProviderDisabledArgs args)
{
Console.WriteLine($"{args.FeedProviderDefinitionId} feed provider was disabled.");
}
OnFeedEnabled, OnFeedDisabled
OnFeedEnabled e OnFeedDisabled vengono richiamati dalla scheda Widget quando un feed è abilitato o disabilitato. I provider di feed non devono eseguire alcuna azione in risposta a queste chiamate al metodo. La chiamata al metodo può essere usata per scopi di telemetria o per aggiornare i parametri della stringa di query o revocare i token di autenticazione, se necessario.
// FeedProvider.cs
public void OnFeedEnabled(FeedEnabledArgs args)
{
Console.WriteLine($"{args.FeedDefinitionId} feed was enabled.");
}
// FeedProvider.cs
public void OnFeedDisabled(FeedDisabledArgs args)
{
Console.WriteLine($"{args.FeedDefinitionId} feed was disabled.");
}
OnCustomQueryParametersRequested
OnCustomQueryParametersRequested viene generato quando la scheda Widget determina che i parametri di query personalizzati associati al provider di feed devono essere aggiornati. Ad esempio, questo metodo può essere generato se l'operazione per recuperare il contenuto del feed dal servizio Web remoto ha esito negativo. La proprietà FeedProviderDefinitionId di CustomQueryParametersRequestedArgs passata a questo metodo specifica il feed per il quale vengono richiesti parametri della stringa di query. Il provider deve rigenerare la stringa di query e passarla nuovamente alla scheda Widget chiamando SetCustomQueryParameters.
// FeedProvider.cs
public void OnCustomQueryParametersRequested(CustomQueryParametersRequestedArgs args)
{
Console.WriteLine($"CustomQueryParamaters were requested for {args.FeedProviderDefinitionId}.");
var updateOptions = new CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId, "param1¶m2");
FeedManager.GetDefault().SetCustomQueryParameters(updateOptions);
}
Implementare una class factory che creerà un'istanza di FeedProvider su richiesta
Affinché l'host del feed comunichi con il provider di feed, è necessario chiamare CoRegisterClassObject. Questa funzione richiede di creare un'implementazione di IClassFactory che creerà un oggetto classe per la classe FeedProvider. La class factory verrà implementata in una classe helper autonoma.
In Visual Studio, fare clic con il pulsante destro del mouse sul progetto ExampleFeedProvider in Esplora soluzioni e selezionare Aggiungi->Classe. Nella finestra di dialogo Aggiungi classe, assegnare alla classe il nome "FactoryHelper" e fare clic su Aggiungi.
Sostituire il contenuto del file FactoryHelper.cs con il codice seguente. Questo codice definisce l'interfaccia IClassFactory e implementa i due metodi, CreateInstance e LockServer. Questo codice è boilerplate tipico per l'implementazione di una class factory e non è specifico per la funzionalità di un provider di feed, ad eccezione del fatto che si indica che l'oggetto classe creato implementa l'interfaccia IFeedProvider.
// FactoryHelper.cs
using Microsoft.Windows.Widgets.Feeds.Providers;
using System.Runtime.InteropServices;
using WinRT;
namespace ExampleFeedProvider
{
namespace Com
{
static class Guids
{
public const string IClassFactory = "00000001-0000-0000-C000-000000000046";
public const string IUnknown = "00000000-0000-0000-C000-000000000046";
}
[ComImport(), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid(Guids.IClassFactory)]
internal interface IClassFactory
{
[PreserveSig]
int CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject);
[PreserveSig]
int LockServer(bool fLock);
}
static class ClassObject
{
public static void Register(Guid clsid, object pUnk, out uint cookie)
{
[DllImport("ole32.dll")]
static extern int CoRegisterClassObject(
[MarshalAs(UnmanagedType.LPStruct)] Guid rclsid,
[MarshalAs(UnmanagedType.IUnknown)] object pUnk,
uint dwClsContext,
uint flags,
out uint lpdwRegister);
int result = CoRegisterClassObject(clsid, pUnk, 0x4, 0x1, out cookie);
if (result != 0)
{
Marshal.ThrowExceptionForHR(result);
}
}
public static int Revoke(uint cookie)
{
[DllImport("ole32.dll")]
static extern int CoRevokeClassObject(uint dwRegister);
return CoRevokeClassObject(cookie);
}
}
}
internal class FeedProviderFactory<T> : Com.IClassFactory
where T : IFeedProvider, new()
{
public int CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject)
{
ppvObject = IntPtr.Zero;
if (pUnkOuter != IntPtr.Zero)
{
Marshal.ThrowExceptionForHR(CLASS_E_NOAGGREGATION);
}
if (riid == typeof(T).GUID || riid == Guid.Parse(Com.Guids.IUnknown))
{
// Create the instance of the .NET object
ppvObject = MarshalInspectable<IFeedProvider>.FromManaged(new T());
}
else
{
// The object that ppvObject points to does not support the
// interface identified by riid.
Marshal.ThrowExceptionForHR(E_NOINTERFACE);
}
return 0;
}
int Com.IClassFactory.LockServer(bool fLock)
{
return 0;
}
private const int CLASS_E_NOAGGREGATION = -2147221232;
private const int E_NOINTERFACE = -2147467262;
}
}
Registrare l'oggetto classe del provider di feed con OLE
Nel file Program.cs per l'eseguibile, viene chiamato CoRegisterClassObject per registrare il provider di feed con OLE, in modo che la scheda Widget possa interagire con essa. Sostituire il contenuto di Program.cs con il codice seguente. In questo modo viene usata l'interfaccia FeedProviderFactory definita in un passaggio precedente per registrare la classe helper FeedProvider. Ai fini del debug, questo esempio chiama GetEnabledFeedProviders nell'istanza di FeedManager predefinita per ottenere un elenco di oggetti FeedProviderInfo che rappresentano i provider di feed abilitati. Il ciclo passa attraverso i fornitori di feed abilitati, usando la proprietà EnabledFeedDefinitionIds per elencare tutti gli ID feed abilitati.
// Program.cs
using Microsoft.Windows.Widgets.Feeds.Providers;
using Microsoft.Windows.Widgets.Providers;
using System;
using System.Runtime.InteropServices;
namespace ExampleFeedProvider
{
public static class Program
{
[DllImport("kernel32.dll")]
static extern IntPtr GetConsoleWindow();
[MTAThread]
static void Main(string[] args)
{
Console.WriteLine("FeedProvider Starting...");
if (args.Length > 0 && args[0] == "-RegisterProcessAsComServer")
{
WinRT.ComWrappersSupport.InitializeComWrappers();
uint registrationHandle;
var factory = new FeedProviderFactory<FeedProvider>();
Com.ClassObject.Register(typeof(FeedProvider).GUID, factory, out registrationHandle);
Console.WriteLine("Feed Provider registered.");
var existingFeedProviders = FeedManager.GetDefault().GetEnabledFeedProviders();
if (existingFeedProviders != null)
{
Console.WriteLine($"There are {existingFeedProviders.Length} FeedProviders currently outstanding:");
foreach (var feedProvider in existingFeedProviders)
{
Console.WriteLine($" ProviderId: {feedProvider.FeedProviderDefinitionId}, DefinitionIds: ");
var m = WidgetManager.GetDefault().GetWidgetIds();
if (feedProvider.EnabledFeedDefinitionIds != null)
{
foreach (var enabledFeedId in feedProvider.EnabledFeedDefinitionIds)
{
Console.WriteLine($" {enabledFeedId} ");
}
}
}
}
if (GetConsoleWindow() != IntPtr.Zero)
{
Console.WriteLine("Press ENTER to exit.");
Console.ReadLine();
}
else
{
while (true)
{
// You should fire an event when all the outstanding
// FeedProviders have been disabled and exit the app.
}
}
}
else
{
Console.WriteLine("Not being launched to service Feed Provider... exiting.");
}
}
}
}
Si noti che questo esempio di codice importa la funzione GetConsoleWindow per determinare se l'app è in esecuzione come applicazione console, il comportamento predefinito per questa procedura dettagliata. Se la funzione restituisce un puntatore valido, le informazioni di debug vengono scritte nella console. In caso contrario, l'app viene eseguita come app di Windows. In tal caso, aspettiamo l'evento impostato nel metodo OnFeedProviderDisabled quando l'elenco dei provider di feed abilitati è vuoto e l'app viene chiusa. Per informazioni sulla conversione dell'app console di esempio in un'app di Windows, consultare Convertire l'app console in un'app di Windows.
Creare un pacchetto dell'app del provider di feed
Nella versione corrente, solo le app in pacchetto possono essere registrate come provider di feed. La procedura seguente illustra il processo di creazione del pacchetto dell'app e l'aggiornamento del manifesto dell'app per registrare l'app con il sistema operativo come provider di feed.
Creare un progetto di creazione di pacchetti MSIX
In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione e selezionare Aggiungi->Nuovo progetto.... Nella finestra di dialogo Aggiungi un nuovo progetto selezionare il modello "Progetto di creazione pacchetti per applicazioni Windows" e fare clic su Avanti. Impostare il nome progetto "ExampleFeedProviderPackage" e fare clic su Crea. Quando richiesto, impostare la versione di destinazione sulla build 22621 o versione successiva e fare clic su OK. Quindi fare clic con il pulsante destro del mouse sul progetto ExampleFeedProviderPackage e selezionare Aggiungi->Riferimento progetto. Selezionare il progetto ExampleFeedProvider e fare clic su OK.
Aggiungere il riferimento pacchetto Windows App SDK al progetto di creazione del pacchetto
È necessario aggiungere un riferimento al pacchetto nuget Windows App SDK al progetto di creazione pacchetti MSIX. In Esplora soluzioni, fare doppio clic sul progetto ExampleFeedProviderPackage per aprire il file ExampleFeedProviderPackage.wapproj. Aggiungere il codice XML seguente all'interno dell'elemento Project.
<!--ExampleWidgetProviderPackage.wapproj-->
<ItemGroup>
<PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.231116003-experimentalpr">
<IncludeAssets>build</IncludeAssets>
</PackageReference>
</ItemGroup>
Nota
Assicurarsi che la Versione specificata nell'elemento PackageReference corrisponda alla versione stabile più recente a cui si fa riferimento nel passaggio precedente.
Se la versione corretta di Windows App SDK è già installata nel computer e non si vuole aggregare il runtime SDK nel pacchetto, è possibile specificare la dipendenza del pacchetto nel file Package.appxmanifest per il progetto ExampleFeedProviderPackage.
<!--Package.appxmanifest-->
...
<Dependencies>
...
<PackageDependency Name="Microsoft.WindowsAppRuntime.1.5.233430000-experimental1" MinVersion="2000.638.7.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
...
</Dependencies>
...
Aggiornare il manifesto del pacchetto
In Esplora soluzioni fare clic con il pulsante destro del mouse sul Package.appxmanifest file e selezionare Visualizza codice per aprire il file XML del manifesto. Successivamente è necessario aggiungere alcune dichiarazioni dello spazio dei nomi per le estensioni del pacchetto dell'app che verranno usati. Aggiungere le definizioni dello spazio dei nomi seguenti all'elemento Pacchetto di livello superiore.
<!-- Package.appmanifest -->
<Package
...
xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"
All'interno dell'elemento Applicazione creare un nuovo elemento vuoto denominato Estensioni. Assicurarsi che venga dopo il tag di chiusura per uap:VisualElements.
<!-- Package.appxmanifest -->
<Application>
...
<Extensions>
</Extensions>
</Application>
La prima estensione da aggiungere è l'estensione ComServer. In questo modo viene registrato il punto di ingresso del file eseguibile con il sistema operativo. Questa estensione è l'app in pacchetto equivalente alla registrazione di un server COM impostando una chiave del registro di sistema e non è specifica per i provider di widget. Aggiungere l'elemento com:Extension seguente come elemento figlio dell'elemento Estensioni. Modificare il GUID nell'attributo Id dell'elemento com:Class impostando il GUID generato in un passaggio precedente durante la definizione della classe FeedProvider.
<!-- Package.appxmanifest -->
<Extensions>
<com:Extension Category="windows.comServer">
<com:ComServer>
<com:ExeServer Executable="ExampleFeedProvider\ExampleFeedProvider.exe" Arguments="-RegisterProcessAsComServer" DisplayName="C# Feed Provider App">
<com:Class Id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" DisplayName="FeedProvider" />
</com:ExeServer>
</com:ComServer>
</com:Extension>
</Extensions>
Aggiungere quindi l'estensione che registra l'app come provider di feed. Incollare l'elemento uap3:Extension nel frammento di codice seguente, come elemento figlio dell'elemento Estensioni. Assicurarsi di sostituire l'attributo ClassId dell'elemento COM con il GUID usato nei passaggi precedenti.
<!-- Package.appxmanifest -->
<Extensions>
...
<uap3:Extension Category="windows.appExtension">
<uap3:AppExtension Name="com.microsoft.windows.widgets.feeds" DisplayName="ContosoFeed" Id="com.examplewidgets.examplefeed" PublicFolder="Public">
<uap3:Properties>
<FeedProvider Icon="ms-appx:Assets\StoreLogo.png" Description="FeedDescription">
<Activation>
<!-- Apps exports COM interface which implements IFeedProvider -->
<CreateInstance ClassId="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" />
</Activation>
<Definitions>
<Definition Id="Contoso_Feed"
DisplayName="Contoso_Feed Feed"
Description="Feed representing Contoso"
ContentUri="https://www.contoso.com/"
Icon="ms-appx:Images\StoreLogo.png">
</Definition>
<Definition Id="Fabrikam_Feed"
DisplayName="Fabrikam Feed"
Description="Feed representing Example"
ContentUri="https://www.fabrikam.com/"
Icon="ms-appx:Images\StoreLogo.png">
</Definition>
</Definitions>
</FeedProvider>
</uap3:Properties>
</uap3:AppExtension>
</uap3:Extension>
</Extensions>
Per descrizioni dettagliate e informazioni sul formato per tutti questi elementi, vedere Formato XML del manifesto del pacchetto del provider di feed.
Test del provider di feed
Assicurarsi di aver selezionato l'architettura corrispondente al computer di sviluppo dall'elenco a discesa Piattaforme soluzione, ad esempio "x64". In Esplora soluzioni, fare clic con il pulsante destro del mouse sulla soluzione e scegliere Compila soluzione. Al termine, fare clic con il pulsante destro del mouse su ExampleWidgetProviderPackage e scegliere Distribuisci. L'app console dovrebbe essere avviata alla distribuzione e i feed verranno abilitati nell'output della console. Aprire la scheda Widget e visualizzare i nuovi feed nelle schede nella parte superiore della sezione feed.
Debug del provider di feed
Dopo aver aggiunto i feed, la piattaforma Widget avvierà l'applicazione del provider di feed per ricevere e inviare informazioni pertinenti sul feed. Per eseguire il debug del feed in esecuzione, è possibile collegare un debugger all'applicazione del provider di feed in esecuzione oppure configurare Visual Studio per avviare automaticamente il debug del processo del provider di feed dopo l'avvio.
Per connettersi al processo in esecuzione:
- In Visual Studio fare clic su Debug -> Connetti a processo.
- Filtrare i processi e trovare l'applicazione del provider di feed desiderata.
- Collegare il debugger.
Per collegare automaticamente il debugger al processo all'avvio iniziale:
- In Visual Studio fare clic su Debug -> Altre destinazioni di debug -> Debug pacchetto applicazione installato.
- Filtrare i pacchetti e trovare il pacchetto del provider di feed desiderato.
- Selezionarlo e selezionare la casella Non avviare, ma eseguire il debug del codice all'avvio.
- Scegliere Connetti.
Convertire l'app console in un'app di Windows
Per convertire l'app console creata in questa procedura dettagliata in un'app di Windows, fare clic con il pulsante destro del mouse sul progetto ExampleFeedProvider in Esplora soluzioni e scegliere Proprietà. In Applicazione->Generale modificare il tipo di output da "Applicazione console" a "Applicazione Windows".
Pubblicazione dell'app del provider di feed
Dopo aver sviluppato e testato il provider di feed, è possibile pubblicare l'app in Microsoft Store per consentire agli utenti di installare i feed nei propri dispositivi. Per istruzioni dettagliate per la pubblicazione di un'app, consultare Pubblicare l'app in Microsoft Store.
Raccolta dell'archivio feed
Dopo che la tua app è stata pubblicata in Microsoft Store, puoi richiedere che la tua app sia inclusa nella raccolta di feed store che consente agli utenti di individuare le app che presentano feed di Windows. Per inviare la richiesta, vedi Inviare il feed/bacheca per aggiungere la raccolta dello Store.
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
