Wywoływanie interfejsów API środowiska uruchomieniowego systemu Windows w aplikacjach pulpitowych

W tym temacie opisano sposób konfigurowania projektów aplikacji klasycznych w celu korzystania z interfejsów API środowiska Windows Runtime (WinRT) udostępnianych przez system operacyjny Windows oraz dodawania nowoczesnych środowisk systemów Windows 11 i Windows 10 do aplikacji klasycznych.

Niektóre interfejsy API środowiska Uruchomieniowego systemu Windows (WinRT) nie są obsługiwane w aplikacjach komputerowych. Aby uzyskać więcej informacji, zobacz API środowiska uruchomieniowego systemu Windows, które nie są obsługiwane w aplikacjach klasycznych.

Modyfikowanie projektu platformy .NET w celu używania interfejsów API środowiska uruchomieniowego systemu Windows

Istnieje kilka opcji dla projektów .NET:

• Począwszy od platformy .NET 6, możesz określić w pliku projektu docelowy program Target Framework Moniker (TFM), aby uzyskać dostęp do interfejsów API WinRT. Ta opcja jest obsługiwana w projektach przeznaczonych dla systemu Windows 10 w wersji 1809 lub nowszej.
• W przypadku wcześniejszych wersji platformy .NET można zainstalować pakiet Microsoft.Windows.SDK.Contracts NuGet, aby dodać wszystkie niezbędne odwołania do projektu. Ta opcja jest obsługiwana w projektach przeznaczonych dla systemu Windows 10 w wersji 1803 lub nowszej.
• Jeśli projekt ma wiele obiektów docelowych .NET 6 (lub nowszych) i starszych wersji platformy .NET, możesz skonfigurować plik projektu tak, aby używał obu opcji.

.NET 6 i nowsze: użyj opcji Docelowego Identyfikatora Platformy

Ta opcja jest obsługiwana tylko w projektach korzystających z platformy .NET 6 (lub nowszej) i docelowej wersji systemu operacyjnego Windows 10 w wersji 1809 lub nowszej. Określając program TFM specyficzny dla systemu operacyjnego Windows w pliku projektu, odwołanie jest dodawane do odpowiedniego zestawu Windows SDK przeznaczonego dla pakietu. Aby uzyskać więcej informacji na temat tego scenariusza, zobacz wpis w blogu Wywoływanie interfejsów API systemu Windows na platformie .NET.

1. Po otwarciu projektu w programie Visual Studio kliknij prawym przyciskiem myszy projekt w eksploratorze rozwiązań i wybierz pozycję Edytuj plik projektu. Plik projektu będzie wyglądać podobnie do tego.

   Notatka

   W poniższym przykładzie przedstawiono OutputTypeWinExe, który określa plik wykonywalny graficznego interfejsu użytkownika systemu Windows (i uniemożliwia otwarcie okna konsoli po uruchomieniu aplikacji). Jeśli aplikacja nie ma graficznego interfejsu użytkownika, OutputType będzie mieć inną wartość. Interfejsy API WinRT można wywoływać z poziomu aplikacji interfejsu użytkownika systemu Windows, aplikacji konsolowych i bibliotek. Ponadto wartość TargetFramework może nie być dokładnie zgodna z poniższym przykładem.

   <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
       <OutputType>WinExe</OutputType>
       <TargetFramework>net5.0</TargetFramework>
     </PropertyGroup>
   </Project>
   

2. Pozostaw wszystkie inne ustawienia bez zmian i zastąp wartość elementu TargetFramework jednym z następujących ciągów:

   • net6.0-windows10.0.17763.0: jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 1809.
   • net6.0-windows10.0.18362.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 1903.
   • net6.0-windows10.0.19041.0: jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 2004.
   • net6.0-windows10.0.22000.0: Jeśli aplikacja jest przeznaczona na początkową wersję systemu Windows 11.
   • net6.0-windows10.0.22621.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 11, wersja 22H2.
   • net6.0-windows10.0.26100.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 11, wersja 24H2.

   Na przykład następujący element dotyczy projektu przeznaczonego dla systemu Windows 10 w wersji 2004.

   <TargetFramework>net6.0-windows10.0.19041.0</TargetFramework>
   

   W nowszych wersjach platformy .NET można zastąpić wartość odpowiednią wersją, na przykład net8.0-windows10.0.19041.0.

3. Zapisz zmiany i zamknij plik projektu.

API WinRT nie są obsługiwane w .NET 6 lub nowszych wersjach.

W programie .NET 6 lub nowszym istnieje kilka interfejsów API środowiska Uruchomieniowego systemu Windows (WinRT) w windows.UI przestrzeni nazw, które nie są obsługiwane. W przypadku wymienionych poniżej interfejsów API istnieją równoważne wersje interfejsów API w przestrzeni nazw WinUI (Microsoft.UI) (na przykład Microsoft.UI.Text). Następujące interfejsy API WinRT nie są obsługiwane na platformie .NET 6 i nowszych wersjach:

• Windows.UI.Colors klasa
• klasa Windows.UI.ColorHelper
• Windows.UI.Text (wszystkie klasy w tej przestrzeni nazw z wyjątkiem dla Windows.UI.Text.FontStretch, Windows.UI.Text.FontStyle, Windows.UI.Text.FontWeight, Windows.UI.Text.UnderlineTypei wszystkie klasy w przestrzeni nazw Windows.UI.Text.Core)
• windows.UI.Xaml (wszystkie klasy w tej przestrzeni nazw)

Obsługa wielu wersji systemu operacyjnego Windows

Właściwość TargetFramework specyficzna dla wersji systemu operacyjnego Windows określa wersję zestawu Windows SDK, z którym kompilowana jest Twoja aplikacja. Ta właściwość określa zestaw dostępnych interfejsów API w czasie kompilacji i udostępnia wartości domyślne dla TargetPlatformVersion i TargetPlatformMinVersion (jeśli nie są jawnie ustawione). Właściwość TargetPlatformVersion nie musi być jawnie zdefiniowana w pliku projektu, ponieważ jest ona automatycznie ustawiana przez wersję systemu operacyjnego TargetFramework.

TargetPlatformMinVersion można przedefiniować na wartość mniejszą niż TargetPlatformVersion (określoną przez wersję właściwości TargetFramework). Umożliwia to uruchamianie aplikacji we wcześniejszych wersjach systemu operacyjnego. Na przykład w pliku projektu można ustawić następujące ustawienia, aby obsługiwać obniżanie poziomu aplikacji do systemu Windows 10 w wersji 1809.

<Project Sdk="Microsoft.NET.Sdk">
 <PropertyGroup>
   <OutputType>WinExe</OutputType>
   <TargetFramework>net6.0-windows10.0.19041.0</TargetFramework>
   <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
 </PropertyGroup>
</Project>

Należy pamiętać, że ustawienie TargetPlatformMinVersion na wersję poniżej TargetPlatformVersion tworzy potencjał wywoływania niedostępnych interfejsów API. Podczas wywoływania interfejsów API WinRT, które nie są dostępne we wszystkich obsługiwanych wersjach systemu operacyjnego, zalecamy ochronę tych wywołań, stosując sprawdzanie ApiInformation. Aby uzyskać więcej informacji, zobacz aplikacje dostosowujące się do wersji.

Wcześniejsze wersje platformy .NET: Zainstaluj pakiet NuGet Microsoft.Windows.SDK.Contracts

Użyj tej opcji, jeśli aplikacja używa platformy .NET Core 3.x lub .NET Framework. Ta opcja jest obsługiwana w projektach przeznaczonych dla systemu Windows 10 w wersji 1803 lub nowszej.

1. Upewnij się, że odwołania do pakietów są włączone:

   1. W programie Visual Studio kliknij pozycję Narzędzia -> Menedżer pakietów NuGet -> Ustawienia menedżera pakietów.
   2. Upewnij się, że PackageReference jest wybrana dla Domyślny Format Zarządzania Pakietami.

2. Po otwarciu projektu w programie Visual Studio kliknij prawym przyciskiem myszy projekt w eksploratorze rozwiązań i wybierz pozycję Zarządzaj pakietami NuGet.

3. W oknie Menedżera pakietów NuGet wybierz kartę Przeglądaj i wyszukaj Microsoft.Windows.SDK.Contracts.

4. Po znalezieniu pakietu Microsoft.Windows.SDK.Contracts w okienku menedżera pakietów NuGet po prawej stronie okna, wybierz wersję pakietu, którą chcesz zainstalować w oparciu o wersję systemu Windows 10, na którą chcesz kierować.

   • 10.0.19041.xxxx: wybierz tę opcję dla systemu Windows 10 w wersji 2004.
   • 10.0.18362.xxxx: wybierz tę opcję dla systemu Windows 10 w wersji 1903.
   • 10.0.17763.xxxx: wybierz tę opcję dla systemu Windows 10 w wersji 1809.
   • 10.0.17134.xxxx: wybierz tę opcję dla systemu Windows 10 w wersji 1803.

5. Kliknij pozycję Zainstaluj.

Skonfiguruj projekty celujące w różne wersje platformy .NET

Jeśli projekt ma wiele obiektów docelowych platformy .NET 6 (lub nowszej) i wcześniejszych wersji (w tym .NET Core 3.x i .NET Framework), możesz skonfigurować plik projektu tak, aby używał programu Target Framework Moniker (TFM) do automatycznego ściągania odwołań interfejsu API WinRT dla platformy .NET 6 (lub nowszego) i użyć pakietu Microsoft.Windows.SDK.Contracts NuGet we wcześniejszych wersjach.

1. Po otwarciu projektu w programie Visual Studio kliknij prawym przyciskiem myszy projekt w eksploratorze rozwiązań i wybierz pozycję Edytuj plik projektu. W poniższym przykładzie pokazano plik projektu dla aplikacji korzystającej z platformy .NET Core 3.1.

   Notatka

   W poniższym przykładzie przedstawiono OutputType dla WinExe, który oznacza wykonywalny plik aplikacji z graficznym interfejsem użytkownika dla systemu Windows (i zapobiega otwarciu okna konsoli po uruchomieniu aplikacji). Jeśli aplikacja nie ma graficznego interfejsu użytkownika, OutputType będzie mieć inną wartość. Interfejsy API WinRT można wywoływać z poziomu aplikacji interfejsu użytkownika systemu Windows, aplikacji konsolowych i bibliotek. Ponadto wartość TargetFramework może nie być dokładnie zgodna z poniższym przykładem.

   <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
     <PropertyGroup>
       <OutputType>WinExe</OutputType>
       <TargetFramework>netcoreapp3.1</TargetFramework>
       <UseWindowsForms>true</UseWindowsForms>
     </PropertyGroup>
   </Project>
   

2. Zastąp element TargetFramework w pliku elementem TargetFrameworks (zwróć uwagę na liczbę mnogą). W tym elemencie określ docelowe monikery platformy (TFMs) dla wszystkich wersji platformy .NET, które chcesz docelowo wspierać, oddzielone średnikami.

   • W przypadku platformy .NET 6 lub nowszej użyj jednego z następujących programów Target Framework Monikers (TFMs):
     • net6.0-windows10.0.17763.0: jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 1809.
     • net6.0-windows10.0.18362.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 1903.
     • net6.0-windows10.0.19041.0: jeśli aplikacja jest przeznaczona dla systemu Windows 10, wersja 2004.
     • net6.0-windows10.0.22000.0: jeśli aplikacja jest przeznaczona na początkową wersję systemu Windows 11.
     • net6.0-windows10.0.22621.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 11, wersja 22H2.
     • net6.0-windows10.0.26100.0: Jeśli aplikacja jest przeznaczona dla systemu Windows 11, wersja 24H2.
   • W przypadku platformy .NET Core 3.x użyj netcoreapp3.0 lub netcoreapp3.1.
   • W przypadku programu .NET Framework użyj net46.

   Poniższy przykład demonstruje, jak obsługiwać jednocześnie wersje .NET Core 3.1 i .NET 6 (dla Windows 10, wersja 2004).

   <TargetFrameworks>netcoreapp3.1;net6.0-windows10.0.19041.0</TargetFrameworks>
   

3. Po elemencie PropertyGroup dodaj element PackageReference zawierający instrukcję warunkową, która instaluje pakiet NuGet Microsoft.Windows.SDK.Contracts dla wszystkich wersji platformy .NET Core 3.x lub .NET Framework, które celuje Twoja aplikacja. Element PackageReference musi być elementem podrzędnym elementu ItemGroup. W poniższym przykładzie pokazano, jak to zrobić dla platformy .NET Core 3.1.

   <ItemGroup>
     <PackageReference Condition="'$(TargetFramework)' == 'netcoreapp3.1'"
                       Include="Microsoft.Windows.SDK.Contracts"
                       Version="10.0.19041.0" />
   </ItemGroup>
   

   Po zakończeniu plik projektu powinien wyglądać podobnie do tego.

   <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
     <PropertyGroup>
       <OutputType>WinExe</OutputType>
       <TargetFrameworks>netcoreapp3.1;net6.0-windows10.0.19041.0</TargetFrameworks>
       <UseWPF>true</UseWPF>
     </PropertyGroup>
     <ItemGroup>
       <PackageReference Condition="'$(TargetFramework)' == 'netcoreapp3.1'"
                        Include="Microsoft.Windows.SDK.Contracts"
                        Version="10.0.19041.0" />
     </ItemGroup>
   </Project>
   

4. Zapisz zmiany i zamknij plik projektu.

Modyfikowanie projektu klasycznego języka C++ (Win32) w celu używania interfejsów API środowiska uruchomieniowego systemu Windows

Używanie C++/WinRT do korzystania z interfejsów API WinRT. C++/WinRT to całkowicie standardowa nowoczesna projekcja języka C++17 dla interfejsów API WinRT zaimplementowana jako biblioteka oparta na plikach nagłówków i zaprojektowana w celu zapewnienia najwyższej klasy dostępu do nowoczesnego interfejsu API systemu Windows.

Aby skonfigurować projekt dla języka C++/WinRT:

• W przypadku nowych projektów można zainstalować C++/WinRT Visual Studio Extension (VSIX) i użyć jednego z szablonów projektów C++/WinRT zawartych w tym rozszerzeniu.
• W przypadku istniejących projektów można zainstalować pakiet NuGet Microsoft.Windows.CppWinRT w projekcie.

Aby uzyskać więcej informacji na temat tych opcji, zobacz obsługa programu Visual Studio dla języka C++/WinRT orazVSIX.

Dodawanie doświadczeń systemu Windows 10

Teraz możesz dodać nowoczesne funkcje, które ożywają, gdy użytkownicy uruchamiają aplikację w systemie Windows 10. Użyj tego przepływu projektowania.

✅ Najpierw zdecyduj, jakie doświadczenia chcesz dodać

Istnieje wiele do wyboru. Możesz na przykład uprościć przepływ zamówień zakupów przy użyciu interfejsów API monetyzacjilub przyciągnąć uwagę do swojej aplikacji, gdy masz coś interesującego do podzielenia się, na przykład nowe zdjęcie opublikowane przez innego użytkownika.

Nawet jeśli użytkownicy ignorują lub odrzucają komunikat, mogą zobaczyć go ponownie w centrum akcji, a następnie kliknąć komunikat, aby otworzyć aplikację. To zwiększa zaangażowanie użytkowników w aplikację i ma dodatkową zaletę, ponieważ wydaje się, że aplikacja jest głęboko zintegrowana z systemem operacyjnym. W dalszej części tego artykułu pokażemy Ci kod tego doświadczenia.

Odwiedź dokumentację UWP , aby uzyskać więcej pomysłów.

✅ zdecydować, czy ulepszyć lub rozszerzyć

Często słyszymy, jak używamy terminów enhance i extend, więc poświęcimy chwilę, aby wyjaśnić dokładnie, co oznacza każdy z tych terminów.

Używamy terminu enhance do opisu interfejsów API WinRT, które można wywoływać bezpośrednio z aplikacji komputerowej, niezależnie od tego, czy jest to aplikacja spakowana. Po wybraniu środowiska systemu Windows 10 zidentyfikuj interfejsy API, które należy utworzyć, a następnie sprawdź, czy ten interfejs API pojawi się na tej liście. Jest to lista interfejsów API, które można wywoływać bezpośrednio z aplikacji komputerowej. Jeśli twój interfejs API nie jest wyświetlany na tej liście, wynika to z faktu, że funkcje skojarzone z tym interfejsem API mogą działać tylko w ramach procesu platformy UWP. Często obejmują one interfejsy API renderujące kod XAML platformy UWP, takie jak kontrolka mapy platformy UWP lub monit o zabezpieczenia funkcji Windows Hello.

Notatka

Chociaż interfejsy API renderujące język XAML platformy UWP zwykle nie mogą być wywoływane bezpośrednio z pulpitu, możesz użyć alternatywnych metod. Jeśli chcesz hostować kontrolki XAML platformy UWP lub inne niestandardowe środowiska wizualne, możesz użyć wysp XAML (począwszy od systemu Windows 10 w wersji 1903) i Visual Layer (począwszy od systemu Windows 10 w wersji 1803). Te funkcje mogą być używane w spakowanych lub rozpakowanych aplikacjach desktopowych.

Jeśli wybrano opcję spakowania aplikacji klasycznej, kolejną opcją jest rozszerzenie aplikacji przez dodanie projektu platformy UWP do rozwiązania. Projekt klasyczny jest nadal punktem wejścia aplikacji, ale projekt platformy UWP zapewnia dostęp do wszystkich interfejsów API, które nie są wyświetlane w tej listy. Aplikacja desktopowa może komunikować się z procesem platformy UWP przy użyciu usługi aplikacyjnej, a my mamy wiele wskazówek dotyczących sposobu jej konfigurowania. Jeśli chcesz dodać doświadczenie wymagające projektu UWP, zobacz Rozszerzanie przy użyciu składników UWP.

✅ Referencyjne kontrakty API

Jeśli możesz wywołać interfejs API bezpośrednio z aplikacji klasycznej, otwórz przeglądarkę i wyszukaj temat referencyjny dla tego interfejsu API. Poniżej podsumowania interfejsu API znajdziesz tabelę opisującą jego kontrakt. Oto przykład tej tabeli:

tabela kontraktów API

Jeśli masz aplikację klasyczną opartą na platformie .NET, dodaj odwołanie do tego kontraktu API, a następnie ustaw właściwość Copy Local tego pliku na wartość False. Jeśli masz projekt oparty na języku C++, dodaj do dodatkowe katalogi dołączania, ścieżkę do folderu zawierającego ten kontrakt.

✅ Wywołaj interfejsy API, aby dodać doświadczenie

Oto kod, którego można użyć, aby wyświetlić okno powiadomień, które omówiliśmy wcześniej. Te interfejsy API są wyświetlane na tej liście , aby można było dodać ten kod do aplikacji na komputer stacjonarny i od razu uruchomić.

using Windows.Foundation;
using Windows.System;
using Windows.UI.Notifications;
using Windows.Data.Xml.Dom;
...

private void ShowToast()
{
    string title = "featured picture of the day";
    string content = "beautiful scenery";
    string image = "https://picsum.photos/360/180?image=104";
    string logo = "https://picsum.photos/64?image=883";

    string xmlString =
    $@"<toast><visual>
       <binding template='ToastGeneric'>
       <text>{title}</text>
       <text>{content}</text>
       <image src='{image}'/>
       <image src='{logo}' placement='appLogoOverride' hint-crop='circle'/>
       </binding>
      </visual></toast>";

    XmlDocument toastXml = new XmlDocument();
    toastXml.LoadXml(xmlString);

    ToastNotification toast = new ToastNotification(toastXml);

    ToastNotificationManager.CreateToastNotifier().Show(toast);
}

#include <sstream>
#include <winrt/Windows.Data.Xml.Dom.h>
#include <winrt/Windows.UI.Notifications.h>

using namespace winrt::Windows::Foundation;
using namespace winrt::Windows::System;
using namespace winrt::Windows::UI::Notifications;
using namespace winrt::Windows::Data::Xml::Dom;

void UWP::ShowToast()
{
    std::wstring const title = L"featured picture of the day";
    std::wstring const content = L"beautiful scenery";
    std::wstring const image = L"https://picsum.photos/360/180?image=104";
    std::wstring const logo = L"https://picsum.photos/64?image=883";

    std::wostringstream xmlString;
    xmlString << L"<toast><visual><binding template='ToastGeneric'>" <<
        L"<text>" << title << L"</text>" <<
        L"<text>" << content << L"</text>" <<
        L"<image src='" << image << L"'/>" <<
        L"<image src='" << logo << L"'" <<
        L" placement='appLogoOverride' hint-crop='circle'/>" <<
        L"</binding></visual></toast>";

    XmlDocument toastXml;

    toastXml.LoadXml(xmlString.str().c_str());

    ToastNotificationManager::CreateToastNotifier().Show(ToastNotification(toastXml));
}

using namespace Windows::Foundation;
using namespace Windows::System;
using namespace Windows::UI::Notifications;
using namespace Windows::Data::Xml::Dom;

void UWP::ShowToast()
{
    Platform::String ^title = "featured picture of the day";
    Platform::String ^content = "beautiful scenery";
    Platform::String ^image = "https://picsum.photos/360/180?image=104";
    Platform::String ^logo = "https://picsum.photos/64?image=883";

    Platform::String ^xmlString =
        L"<toast><visual><binding template='ToastGeneric'>" +
        L"<text>" + title + "</text>" +
        L"<text>"+ content + "</text>" +
        L"<image src='" + image + "'/>" +
        L"<image src='" + logo + "'" +
        L" placement='appLogoOverride' hint-crop='circle'/>" +
        L"</binding></visual></toast>";

    XmlDocument ^toastXml = ref new XmlDocument();

    toastXml->LoadXml(xmlString);

    ToastNotificationManager::CreateToastNotifier()->Show(ref new ToastNotification(toastXml));
}

Aby dowiedzieć się więcej o powiadomieniach, zobacz adaptacyjne i interaktywne powiadomienia typu toast.

Obsługa baz instalacji systemów Windows XP, Windows Vista i Windows 7/8

Możesz zmodernizować aplikację dla systemu Windows 10 bez konieczności tworzenia nowej gałęzi i obsługiwania oddzielnych baz kodu.

Jeśli chcesz utworzyć oddzielne pliki binarne dla użytkowników systemu Windows 10, użyj kompilacji warunkowej. Jeśli wolisz utworzyć jeden zestaw plików binarnych wdrożonych dla wszystkich użytkowników systemu Windows, użyj kontroli środowiska uruchomieniowego.

Przyjrzyjmy się każdej opcji.

Kompilacja warunkowa

Możesz zachować jedną bazę kodu i skompilować zestaw plików binarnych tylko dla użytkowników systemu Windows 10.

Najpierw dodaj nową konfigurację kompilacji do projektu.

W przypadku tej konfiguracji kompilacji utwórz stałą, aby można było zidentyfikować kod, który wywołuje interfejsy API WinRT.

Dla projektów opartych na .NET, stała nosi nazwę stałej kompilacji warunkowej .

W przypadku projektów opartych na języku C++stała jest nazywana definicją preprocesora .

stała definicji preprocesora

Dodaj tę stałą przed każdym blokiem kodu UWP.

[System.Diagnostics.Conditional("_UWP")]
private void ShowToast()
{
 ...
}

#if _UWP
void UWP::ShowToast()
{
 ...
}
#endif

Kompilator kompiluje ten kod tylko wtedy, gdy ta stała jest zdefiniowana w aktywnej konfiguracji kompilacji.

Testy środowiska uruchomieniowego

Można skompilować jeden zestaw plików binarnych dla wszystkich użytkowników systemu Windows niezależnie od używanej wersji systemu Windows. Aplikacja wywołuje interfejsy API WinRT tylko wtedy, gdy użytkownik uruchamia aplikację jako spakowana aplikacja w systemie Windows 10.

Najprostszym sposobem dodania kontroli środowiska uruchomieniowego do kodu jest zainstalowanie tego pakietu NuGet: pomocnicy Desktop Bridge, a następnie użycie metody IsRunningAsUWP() w celu wyłączenia całego kodu, który wywołuje interfejsy API WinRT. Zobacz ten wpis na blogu, aby uzyskać więcej informacji: Desktop Bridge — identyfikowanie kontekstu aplikacji.

Powiązane przykłady

• Przykładowy "Witaj, świecie"
• kafelek pomocniczy
• Przykładowy interfejs API sklepu
• aplikacji WinForms, która implementuje UpdateTask platformy UWP
• Mostek aplikacji desktopowych do przykładów platformy UWP

Znajdowanie odpowiedzi na pytania

Masz pytania? Zapytaj nas w witrynie Stack Overflow. Nasz zespół monitoruje te tagi . Możesz również zapytać na naszych forach .