Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Hinweis
Einige Informationen beziehen sich auf Vorabversionen, die vor der kommerziellen Freigabe grundlegend geändert werden können. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Dieser Artikel führt Sie durch die Erstellung eines einfachen Feedanbieters, der einen Feed-Inhalts-URI registriert und die Schnittstelle IFeedProvider implementiert. Die Methoden dieser Schnittstelle werden vom Widgets Board aufgerufen, um benutzerdefinierte Abfrage-Zeichenkettenparameter anzufordern, in der Regel zur Unterstützung von Authentifizierungsszenarien. Feedanbieter können einen einzelnen Feed oder mehrere Feeds unterstützen.
Informationen zum Implementieren eines Feedanbieters mithilfe von C++/WinRT finden Sie unter Implementieren eines Feedanbieters in einer Win32-App (C++/WinRT).
Voraussetzungen
- Auf Ihrem Gerät muss der Entwicklermodus aktiviert sein. Weitere Informationen finden Sie unter "Einstellungen für Entwickler".
- Visual Studio 2022 oder höher, mit der Workload für die UWP-Entwicklung.
Erstellen einer neuen Konsolen-App in C#
Erstellen Sie in Visual Studio ein neues Projekt. Legen Sie im Dialogfeld Neues Projekt erstellen den Sprachfilter auf „C#“ und den Plattformfilter auf „Windows“ fest, und wählen Sie dann die Projektvorlage „Konsolen-App“ aus. Nennen Sie das neue Projekt „ExampleFeedProvider“. Stellen Sie sicher, dass Platzieren Sie die Lösung und das Projekt im selben Verzeichnis deaktiviert ist. Wenn Sie dazu aufgefordert werden, legen Sie die .NET-Zielversion auf 6.0 fest.
Wenn das Projekt geladen wird, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und wählen Sie dann Eigenschaften aus. Scrollen Sie auf der Seite Allgemein nach unten zu Zielbetriebssystem, und wählen Sie „Windows“ aus. Wählen Sie unter Zielbetriebssystemversion die Version 10.022631.2787 oder höher aus.
Beachten Sie, dass in dieser exemplarischen Vorgehensweise eine Konsolen-App verwendet wird, die das Konsolenfenster anzeigt, wenn der Feed aktiviert wird, um einfaches Debuggen zu ermöglichen. Wenn Sie bereit sind, Ihre Feedanbieter-App zu veröffentlichen, können Sie die Konsolenanwendung mithilfe der Schritte unter Konvertieren Ihrer Konsolen-App in eine Windows-App in eine Windows-Anwendung konvertieren.
Hinzufügen von Verweisen auf das NuGet-Paket der Windows App
In diesem Beispiel wird das neueste stabile NuGet-Paket der Windows App SDK verwendet. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf Abhängigkeiten, und wählen Sie NuGet-Pakete verwalten... aus. Wählen Sie im NuGet-Paket-Manager die Registerkarte Durchsuchen aus, und suchen Sie nach „Microsoft.WindowsAppSDK“. Wählen Sie in der Dropdownliste Version die neueste stabile Version aus, und klicken Sie dann auf Installieren.
Hinzufügen einer FeedProvider-Klasse zur Handhabung von Feedvorgängen
Klicken Sie in Visual Studio im ExampleFeedProvider mit der rechten Maustaste auf das Projekt , und wählen Sie Hinzufügen -> Klasse aus. Nennen Sie die Klasse im Dialogfeld Klasse hinzufügen „FeedProvider“, und klicken Sie dann auf Hinzufügen. Aktualisieren Sie die Klassendefinition in der generierten FeedProvider.cs-Datei, um anzugeben, dass sie die IFeedProvider-Schnittstelle implementiert.
Erstellen Sie eine CLSID. Diese wird verwendet, um Ihren Feedanbieter für die COM-Aktivierung zu identifizieren. Generieren Sie eine GUID in Visual Studio, indem Sie zu Tools -> GUID erstellen wechseln. Speichern Sie diese GUID in einer Textdatei, die später beim Packen der Feedanbieter-App verwendet werden soll. Ersetzen Sie die GUID in den Anmerkungen für die im folgenden Beispiel gezeigte FeedProvider-Klasse.
// FeedProvider.cs
using Microsoft.Windows.Widgets.Feeds.Providers;
...
[ComVisible(true)]
[ComDefaultInterface(typeof(IFeedProvider))]
[Guid("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")]
public sealed class FeedProvider : IFeedProvider
Implementieren der IFeedProvider-Methoden
In den nächsten Abschnitten werden die Methoden der IFeedProvider-Schnittstelle implementiert.
Hinweis
Objekte, die an die Rückrufmethoden der IFeedProvider-Schnittstelle übergeben werden, sind nur innerhalb des Rückrufs gültig. Sie sollten keine Verweise auf diese Objekte speichern, da ihr Verhalten außerhalb des Kontexts des Rückrufs nicht definiert ist.
OnFeedProviderEnabled
Die OnFeedProviderEnabled-Methode wird aufgerufen, wenn ein mit dem Anbieter verknüpfter Feed vom Widgets Board-Host erstellt wird. In der Implementierung dieser Methode generieren Sie eine Abfragezeichenkette mit den Parametern, die an die URL übergeben werden, die den Feed-Inhalt bereitstellt, einschließlich aller erforderlichen Authentifizierungstoken. Erstellen Sie eine Instanz von CustomQueryParametersUpdateOptions, und übergeben Sie die FeedProviderDefinitionId aus den Ereignisargumenten, die den aktivierten Feed identifiziert, sowie die Abfragezeichenkette. Holen Sie sich den Standard-FeedManager und rufen Sie SetCustomQueryParameters auf, um die Abfragezeichenkettenparameter beim Widgets Board zu registrieren.
// 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);
}
BeiDeaktiviertemFeedProvider
OnFeedProviderDisabled wird aufgerufen, wenn das Widgets Board alle Feeds für diesen Anbieter deaktiviert hat. Feedanbieter müssen keine Aktionen als Reaktion auf diesen Methodenaufruf ausführen. Der Methodenaufruf kann zu Telemetriezwecken oder zur Aktualisierung der Abfragezeichenkettenparameter oder zum Widerruf von Authentifizierungstoken verwendet werden, falls erforderlich. Wenn die App nur einen einzelnen Feedanbieter unterstützt oder alle von der App unterstützten Feedanbieter deaktiviert wurden, kann die App als Reaktion auf diesen Rückruf beendet werden.
// FeedProvider.cs
public void OnFeedProviderDisabled(FeedProviderDisabledArgs args)
{
Console.WriteLine($"{args.FeedProviderDefinitionId} feed provider was disabled.");
}
BeiFeedAktiviert, BeiFeedDeaktiviert
OnFeedEnabled und OnFeedDisabled werden vom Widgets Board aufgerufen, wenn ein Feed aktiviert oder deaktiviert ist. Feedanbieter müssen keine Aktionen als Reaktion auf diese Methodenaufrufe ausführen. Der Methodenaufruf kann zu Telemetriezwecken oder zur Aktualisierung der Abfragezeichenkettenparameter oder zum Widerruf von Authentifizierungstoken verwendet werden, falls erforderlich.
// 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.");
}
BeiAnforderungBenutzerdefinierterAbfrageparameter
OnCustomQueryParametersRequested wird ausgelöst, wenn das Widgets Board feststellt, dass die mit dem Feedanbieter verbundenen benutzerdefinierten Abfrageparameter aktualisiert werden müssen. Diese Methode kann beispielsweise ausgelöst werden, wenn der Vorgang zum Abrufen von Feedinhalten aus dem Remote-Webdienst fehlschlägt. Die FeedProviderDefinitionId-Eigenschaft der an diese Methode übergebenen CustomQueryParametersRequestedArgs gibt den Feed an, für den Abfragezeichenkettenparameter angefordert werden. Der Anbieter sollte die Abfragezeichenkette neu generieren und zurück an das Widgets Board übergeben, indem er SetCustomQueryParameters aufruft.
// 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);
}
Implementieren einer Klassenfactory, die FeedProvider bei Bedarf instanziiert
Damit der Feedhost mit dem Feedanbieter kommunizieren kann, muss CoRegisterClassObject aufgerufen werden. Diese Funktion erfordert die Erstellung einer Implementierung der IClassFactory, die wiederum ein Klassenobjekt für die FeedProvider-Klasse erstellt. Die Klassenfactory wird in einer eigenständigen Hilfsklasse implementiert.
Klicken Sie in Visual Studio im ExampleFeedProvider mit der rechten Maustaste auf das Projekt , und wählen Sie Hinzufügen -> Klasse aus. Nennen Sie die Klasse im Dialogfeld Klasse hinzufügen „FactoryHelper“, und klicken Sie dann auf Hinzufügen.
Ersetzen Sie den Inhalt der Datei „FactoryHelper.cs“ mit folgendem Code. Dieser Code definiert die IClassFactory-Schnittstelle und implementiert ihre beiden Methoden CreateInstance und LockServer. Dieser Code ist ein typischer Baustein für die Implementierung einer Klassenfactory und nicht spezifisch für die Funktionalität eines Feedanbieters. Es wird lediglich angegeben, dass das zu erstellende Klassenobjekt die IFeedProvider-Schnittstelle implementiert.
// 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;
}
}
Registrieren des Feedanbieter-Klassenobjekts bei OLE
In der Datei „Program.cs“ für die ausführbare Datei wird CoRegisterClassObject aufgerufen, um den Feedanbieter bei OLE zu registrieren, damit das Widgets Board damit interagieren kann. Ersetzen Sie die Inhalte von Program.cs durch den folgenden Code. Dabei wird die Schnittstelle FeedProviderFactory verwendet, die wir in einem früheren Schritt definiert haben, um die Hilfsklasse FeedProvider zu registrieren. Zu Debugging-Zwecken ruft dieses Beispiel GetEnabledFeedProviders auf der Standardinstanz von FeedManager auf, um eine Liste von FeedProviderInfo-Objekten zu erhalten, die die aktivierten Feed-Anbieter darstellen. Die Schleife durchläuft die aktivierten Feedanbieter mithilfe der EnabledFeedDefinitionIds-Eigenschaft, um alle aktivierten Feed-IDs auflisten zu können.
// 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.");
}
}
}
}
Beachten Sie, dass in diesem Codebeispiel die Funktion GetConsoleWindow importiert wird, um zu bestimmen, ob die App als Konsolenanwendung ausgeführt wird. Dies ist das Standardverhalten für diese exemplarische Vorgehensweise. Wenn die Funktion einen gültigen Zeiger zurückgibt, werden Debuginformationen in die Konsole geschrieben. Andernfalls wird die App als Windows-App ausgeführt. In diesem Fall wird auf das in der OnFeedProviderDisabled-Methode festgelegte Ereignis gewartet, wenn die Liste der aktivierten Feedanbieter leer ist und die App beendet wird. Informationen zum Konvertieren der Beispielkonsolen-App in eine Windows-App finden Sie unter Konvertieren Ihrer Konsolen-App in eine Windows-App.
Packen der Feedanbieter-App
Im aktuellen Release können nur gepackte Apps als Feedanbieter registriert werden. Die folgenden Schritte führen Sie durch den Vorgang zum Packen Ihrer App und zum Aktualisieren des App-Manifests, um Ihre App beim Betriebssystem als Feedanbieter zu registrieren.
Erstellen eines MSIX-Paketerstellungsprojekts
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihre Projektmappe, und wählen Sie Hinzufügen -> Neues Projekt... aus. Wählen Sie im Dialogfeld Neues Projekt hinzufügen die Vorlage „Paketerstellungsprojekt für Windows-Anwendungen“ aus, und klicken Sie auf Weiter. Legen Sie den Projektnamen auf „ExampleFeedProviderPackage“ fest, und klicken Sie auf Erstellen. Wenn Sie dazu aufgefordert werden, legen Sie die Zielversion auf Version 22621 oder höher fest, und klicken Sie auf OK. Klicken Sie als Nächstes mit der rechten Maustaste auf das Projekt „ExampleFeedProviderPackage“, und wählen Sie Hinzufügen –> Projektverweis aus. Wählen Sie das Projekt ExampleFeedProvider aus, und klicken Sie auf „OK“.
Hinzufügen eines Windows App SDK-Paketverweises zum Paketprojekt
Sie müssen dem MSIX-Paketprojekt einen Verweis auf das NuGet-Paket des Windows App SDK hinzufügen. Doppelklicken Sie im Projektmappen-Explorer auf das Projekt „ExampleFeedProviderPackage“, um die Datei „ExampleFeedProviderPackage.wapproj“ zu öffnen. Fügen Sie im Project-Element den folgenden XML-Code hinzu.
<!--ExampleWidgetProviderPackage.wapproj-->
<ItemGroup>
<PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.231116003-experimentalpr">
<IncludeAssets>build</IncludeAssets>
</PackageReference>
</ItemGroup>
Hinweis
Stellen Sie sicher, dass die im PackageReference-Element angegebene Version mit der neuesten stabilen Version übereinstimmt, auf die Sie im vorherigen Schritt verwiesen haben.
Wenn die richtige Version des Windows App SDK bereits auf dem Computer installiert ist und Sie die SDK-Runtime nicht in Ihrem Paket bündeln möchten, können Sie die Paketabhängigkeit in der Datei „Package.appxmanifest“ für das Projekt „ExampleFeedProviderPackage“ angeben.
<!--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>
...
Aktualisieren des Paketmanifests
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Package.appxmanifest, und wählen Sie Code anzeigen aus, um die XML-Datei des Manifests zu öffnen. Als Nächstes müssen Sie einige Namespacedeklarationen für die verwendeten App-Paketerweiterungen hinzufügen. Fügen Sie dem Package-Element der obersten Ebene die folgenden Namespacedefinitionen hinzu.
<!-- Package.appmanifest -->
<Package
...
xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"
Erstellen Sie im Application-Element ein neues leeres Element namens Extensions. Stellen Sie sicher, dass Sie dieses Element nach dem schließenden Tag für uap:VisualElements angeben.
<!-- Package.appxmanifest -->
<Application>
...
<Extensions>
</Extensions>
</Application>
Die erste Erweiterung, die hinzugefügt werden muss, ist die ComServer-Erweiterung. Dadurch wird der Einstiegspunkt der ausführbaren Datei beim Betriebssystem registriert. Diese Erweiterung ist das Paket-App-Äquivalent zur Registrierung eines COM-Servers durch Festlegen eines Registrierungsschlüssels und nicht spezifisch für Widget-Anbieter. Fügen Sie das folgende com:Extension-Element als untergeordnetes Element des Elements Extensions hinzu. Ändern Sie die GUID im Id-Attribut des com:Class-Elements in die GUID, die Sie in einem vorherigen Schritt bei der Definition der FeedProvider-Klasse generiert haben.
<!-- 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>
Fügen Sie als Nächstes die Erweiterung hinzu, die die App als Feedanbieter registriert. Fügen Sie das uap3:Extension-Element als untergeordnetes Element des Extensions-Elements in den folgenden Codeausschnitt ein. Ersetzen Sie das ClassId-Attribut des COM-Elements durch die GUID, die Sie in den vorherigen Schritten verwendet haben.
<!-- 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>
Ausführliche Beschreibungen und Formatinformationen für all diese Elemente finden Sie unter XML-Format des Feedanbieter-Paketmanifests.
Testen des Feedanbieters
Stellen Sie sicher, dass Sie in der Dropdownliste Projektmappenplattformen die Architektur ausgewählt haben, die Ihrem Entwicklungscomputer entspricht, z. B. „x64“. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, und wählen Sie Projektmappe erstellen aus. Klicken Sie anschließend mit der rechten Maustaste auf Ihr ExampleWidgetProviderPackage, und wählen Sie Bereitstellen aus. Die Konsolenanwendung sollte bei der Bereitstellung starten und Sie werden sehen, dass die Feeds in der Konsolenausgabe aktiviert werden. Öffnen Sie das Widgets Board. Sie sollten die neuen Feeds auf den Registerkarten am oberen Rand des Feeds-Abschnitts sehen.
Debuggen des Feedanbieters
Nachdem Sie Ihre Feeds angeheftet haben, startet die Widgetplattform Ihre Feedanbieteranwendung, um relevante Informationen über den Feed zu empfangen und zu senden. Zum Debuggen des ausgeführten Feeds können Sie entweder einen Debugger an die ausgeführte Feedanbieteranwendung anfügen oder Visual Studio so einrichten, dass das Debuggen des Feedanbieterprozesses nach dem Start automatisch gestartet wird.
Zum Anfügen an den ausgeführten Prozess:
- Klicken Sie in Visual Studio auf Debuggen -> An den Prozess anhängen.
- Filtern Sie die Prozesse, und suchen Sie ihre gewünschte Feedanbieteranwendung.
- Fügen Sie den Debugger an.
Zum Anfügen des Debuggers an den Prozess beim erstmaligen Start:
- Klicken Sie in Visual Studio auf Debuggen -> Andere Debugziele -> Installiertes App-Paket debuggen aus.
- Filtern Sie die Pakete, und suchen Sie ihr gewünschtes Feedanbieterpaket.
- Wählen Sie es aus, und aktivieren Sie das Kontrollkästchen „Eigenen Code zunächst nicht starten, sondern debuggen“.
- Klicken Sie auf Anfügenaus.
Konvertieren Sie Ihre Konsolen-App in eine Windows-App
Um die in dieser exemplarischen Vorgehensweise erstellte Konsolen-App in eine Windows-App zu konvertieren, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt ExampleFeedProvider, und wählen Sie Eigenschaften aus. Ändern Sie unter „Anwendung -> Allgemein“ den Ausgabetyp von „Konsolenanwendung“ in „Windows-Anwendung“.
Veröffentlichen Ihrer Feedanbieter-App
Nachdem Sie Ihren Feedanbieter entwickelt und getestet haben, können Sie Ihre App im Microsoft Store veröffentlichen, damit Benutzer Ihre Feeds auf ihren Geräten installieren können. Eine schrittweise Anleitung zum Veröffentlichen einer App finden Sie unter Veröffentlichen Ihrer App im Microsoft Store.
Die Feeds Store-Sammlung
Nachdem Ihre App im Microsoft Store veröffentlicht wurde, können Sie anfordern, dass Ihre App in die Feeds Store-Sammlung aufgenommen wird, mit der Benutzer Apps entdecken können, die Windows-Feeds enthalten. Informationen zum Übermitteln Ihrer Anfrage finden Sie unter "Übermitteln Ihres Feeds/Boards" zur Ergänzung zur Store-Sammlung.
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
Windows developer