Generowanie projekcji języka C# z komponentu C++/WinRT, dystrybuowanej jako pakiet NuGet dla aplikacji .NET

W tym temacie omówimy, jak za pomocą C#/WinRT wygenerować zestaw projekcji .NET dla języka C# (lub zestaw interoperacyjności) na podstawie składnika środowisko wykonawcze systemu Windows napisanego w C++/WinRT i rozprowadzać go jako pakiet NuGet dla aplikacji .NET.

W .NET 6 i nowszych użycie plików metadanych Windows (WinMD) nie jest już obsługiwane (zobacz Obsługa wbudowanego środowiska WinRT jest usuwana z .NET). Zamiast tego narzędzie C#/WinRT może służyć do generowania zestawu projekcji dla dowolnego pliku WinMD, który następnie umożliwia użycie składników WinRT z .NET aplikacji. Zestaw projekcji jest również znany jako zestaw międzyoperacyjny. W tym przewodniku pokazano, jak wykonać następujące czynności:

Użyj pakietu C#/WinRT, aby wygenerować projekcję języka C# na podstawie składnika C++/WinRT.
Dystrybuuj składnik wraz z zestawem projekcji jako pakiet NuGet.
Spożytkuj pakiet NuGet w aplikacji konsolowej .NET.

Wymagania wstępne

Ten przewodnik i odpowiedni przykład wymagają następujących narzędzi i składników:

Visual Studio 2022 lub nowszym z zainstalowanym obciążeniem programowania platforma uniwersalna systemu Windows. W Szczegóły instalacji>rozwój platformy uniwersalnej Windows sprawdź opcję narzędzia C++ (v14x) dla platformy uniwersalnej Windows.
.NET 8.0 SDK (LTS) lub nowszy.

W tym przewodniku będziemy używać Visual Studio 2022 lub nowszego i .NET 8.

Ważne

Ponadto należy pobrać lub sklonować przykładowy kod dotyczący tego tematu z przykładu projekcji C#/WinRT z serwisu GitHub. Odwiedź CsWinRTi kliknij zielony przycisk kod, aby uzyskać URL git clone. Pamiętaj, aby odczytać plik README.md w celach demonstracyjnych.

Tworzenie prostego składnika środowisko wykonawcze systemu Windows języka C++/WinRT

Aby wykonać czynności opisane w tym przewodniku, musisz najpierw mieć składnik C++/WinRT środowisko wykonawcze systemu Windows (WRC), z którego ma zostać wygenerowany zestaw projekcji języka C#.

W tym przewodniku użyto SimpleMathComponent WRC z przykładu projekcji C#/WinRT na GitHubie, który został już pobrany lub sklonowany. SimpleMathComponent został utworzony na podstawie szablonu projektu środowisko wykonawcze systemu Windows Component (C++/WinRT) Visual Studio.

Aby otworzyć projekt SimpleMathComponent w Visual Studio, otwórz plik \CsWinRT\src\Samples\NetProjectionSample\CppWinRTComponentProjectionSample.sln, który znajdziesz w pobranym lub sklonowanym repozytorium.

Kod w tym projekcie udostępnia funkcje podstawowych operacji matematycznych pokazanych w poniższym pliku nagłówkowym.

// SimpleMath.h
...
namespace winrt::SimpleMathComponent::implementation
{
    struct SimpleMath: SimpleMathT<SimpleMath>
    {
        SimpleMath() = default;
        double add(double firstNumber, double secondNumber);
        double subtract(double firstNumber, double secondNumber);
        double multiply(double firstNumber, double secondNumber);
        double divide(double firstNumber, double secondNumber);
    };
}

Możesz potwierdzić, że właściwość Windows Desktop Compatible jest ustawiona na es dla projektu składnika SimpleMathComponent C++/WinRT środowisko wykonawcze systemu Windows. W tym celu we właściwościach projektu dla SimpleMathComponent, w sekcji Właściwości konfiguracji>Ogólne>Domyślne ustawienia projektu, ustaw właściwość Windows Desktop Compatible na Tak. Dzięki temu prawidłowe pliki binarne środowiska uruchomieniowego są ładowane dla aplikacji pulpitowych .NET.

strona właściwości zgodnej z programem Desktop

Aby uzyskać bardziej szczegółowe instrukcje dotyczące tworzenia składnika C++/WinRT i generowania pliku WinMD, zobacz środowisko wykonawcze systemu Windows components with C++/WinRT (Składniki języka C++/WinRT

Uwaga / Notatka

Jeśli implementujesz IInspectable::GetRuntimeClassName w składniku, musi zwrócić prawidłową nazwę klasy WinRT. Ponieważ język C#/WinRT używa ciągu nazwy klasy dla międzyoperacyjności, nieprawidłowa nazwa klasy środowiska uruchomieniowego zgłosi InvalidCastException.

Dodaj projekt symulacji do rozwiązania składnika

Najpierw przy użyciu rozwiązania CppWinRTComponentProjectionSample nadal otwarte w Visual Studio usuń projekt SimpleMathProjection z tego rozwiązania. Następnie usuń z systemu plików folder SimpleMathProjection (lub zmień jego nazwę, jeśli wolisz). Te kroki są niezbędne, aby można było wykonać ten przewodnik krok po kroku.

Dodaj nowy projekt biblioteki języka C# do rozwiązania.
1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł rozwiązania i kliknij Dodaj>Nowy Project.
2. W oknie dialogowym Dodawanie nowego projektu wpisz Class Library w polu wyszukiwania. Wybierz C# z listy języków, a następnie wybierz Windows z listy platformy. Wybierz szablon projektu języka C#, który jest nazywany po prostu biblioteką klas (bez prefiksów ani sufiksów), a następnie kliknij przycisk Dalej.
3. Nadaj nowemu projektowi nazwę SimpleMathProjection. Lokalizacja powinna być już ustawiona na ten sam \CsWinRT\src\Samples\NetProjectionSample folder, w którego znajduje się folder SimpleMathComponent , ale upewnij się, że. Następnie kliknij Dalej.
4. Na stronie Dodaj informacje wybierz .NET 8.0 (obsługa długoterminowa) a następnie wybierz pozycję Utwórz.
Usuń plik szkieletu Class1.cs z projektu.
Wykonaj poniższe kroki, aby zainstalować pakiet NuGet C#/WinRT.
1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy SimpleMathProjection projekt i wybierz Zarządzaj pakietami NuGet.
2. Na karcie Browse wpisz lub wklej Microsoft.Windows. CsWinRT w polu wyszukiwania w wynikach wyszukiwania wybierz element z najnowszą wersją, a następnie kliknij pozycję Install aby zainstalować pakiet w projekcie SimpleMathProjection.
Dodaj do SimpleMathProjection odwołanie do projektu SimpleMathComponent. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy na węzeł Dependencies w węźle projektu SimpleMathProjection, wybierz Dodaj odwołanie do projektu i wybierz projekt SimpleMathComponent>OK.

Nie próbuj jeszcze budować projektu. Zrobimy to w późniejszym kroku.

Do tej pory twój Eksplorator rozwiązań powinien wyglądać podobnie do tego (numery wersji będą inne).

Eksplorator rozwiązań przedstawiający zależności projektu rzutowania

Budowanie projektów z kodu źródłowego

W przypadku rozwiązania CppWinRTComponentProjectionSample w przykładzie projekcji C#/WinRT (który został pobrany lub sklonowany z GitHub i teraz jest otwarty), lokalizacja wyników kompilacji jest skonfigurowana za pomocą pliku Directory.Build.props do kompilacji poza katalogiem źródłowym. Oznacza to, że pliki z danych wyjściowych kompilacji są generowane poza folderem źródłowym. Zalecamy kompilowanie poza źródłem podczas korzystania z narzędzia C#/WinRT. Zapobiega to nieumyślnemu pobraniu wszystkich plików *.cs w katalogu głównym projektu, co może powodować błędy zduplikowanego typu (na przykład podczas kompilowania dla wielu konfiguracji i/lub platform).

Mimo że jest to już skonfigurowane dla rozwiązania CppWinRTComponentProjectionSample , wykonaj poniższe kroki, aby samodzielnie przeprowadzić konfigurację.

Aby skonfigurować rozwiązanie do kompilowania poza źródłem:

Po otwarciu rozwiązania CppWinRTComponentProjectionSample kliknij prawym przyciskiem myszy węzeł rozwiązania, a następnie wybierz pozycję Dodaj>nowy element. Wybierz element Plik XML i nadaj mu nazwę Directory.Build.props (bez .xml rozszerzenia). Kliknij przycisk Tak , aby zastąpić istniejący plik.

Zastąp zawartość pliku Directory.Build.props poniższą konfiguracją.

<Project>
  <PropertyGroup>
    <BuildOutDir>$([MSBuild]::NormalizeDirectory('$(SolutionDir)', '_build', '$(Platform)', '$(Configuration)'))</BuildOutDir>
    <OutDir>$([MSBuild]::NormalizeDirectory('$(BuildOutDir)', '$(MSBuildProjectName)', 'bin'))</OutDir>
    <IntDir>$([MSBuild]::NormalizeDirectory('$(BuildOutDir)', '$(MSBuildProjectName)', 'obj'))</IntDir>
  </PropertyGroup>
</Project>

Zapisz i zamknij plik Directory.Build.props.

Edytuj plik projektu dla uruchomienia C#/WinRT

Aby można było wywołać cswinrt.exe narzędzie w celu wygenerowania zestawu projekcji, należy najpierw edytować plik projektu, aby określić kilka właściwości projektu.

W Eksplorator rozwiązań kliknij dwukrotnie węzeł SimpleMathProjection aby otworzyć plik projektu w edytorze.
Zaktualizuj element TargetFramework, aby był przeznaczony dla określonej wersji zestawu SDK Windows. Spowoduje to dodanie zależności zestawów, które są niezbędne do obsługi międzyoperacyjnej i projekcji. Ten przykład dotyczy wersji zestawu SDK Windows net6.0-windows10.0.19041.0 (znanej również jako Windows 10, wersja 2004). Platform Ustaw element na "AnyCPU", aby wynikowy zestaw projekcji mógł być odwoływany z dowolnej architektury aplikacji. Aby umożliwić aplikacjom referencyjnym obsługę wcześniejszych wersji zestawu SDK Windows, można również ustawić właściwość TargetPlatformMinimumVersion.
```
<PropertyGroup>
  <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
  
  <Platform>AnyCPU</Platform>
</PropertyGroup>
```
Uwaga / Notatka

W tym przewodniku i powiązanym przykładowym kodzie rozwiązanie jest tworzone dla x64 i Release. Należy pamiętać, że projekt SimpleMathProjection jest skonfigurowany do kompilowania dla platformy AnyCPU dla wszystkich konfiguracji architektury rozwiązania.
Dodaj drugi PropertyGroup element (bezpośrednio po pierwszym), który ustawia kilka właściwości języka C#/WinRT.
```
<PropertyGroup>
  <CsWinRTIncludes>SimpleMathComponent</CsWinRTIncludes>
  <CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
</PropertyGroup>
```
Poniżej przedstawiono kilka szczegółów dotyczących ustawień w tym przykładzie:
- Właściwość CsWinRTIncludes określa, które przestrzenie nazw mają być projektowane.
- Właściwość CsWinRTGeneratedFilesDir ustawia katalog wyjściowy, w którym są generowane pliki źródłowe projekcji. Ta właściwość jest ustawiona na OutDir, zdefiniowaną w pliku Directory.Build.props z powyższej sekcji.
Zapisz i zamknij plik SimpleMathProjection.csproj, a następnie kliknij polecenie Załaduj ponownie projekty w razie potrzeby.

Tworzenie pakietu NuGet przy użyciu projekcji

Aby dystrybuować zestaw projekcji dla deweloperów aplikacji .NET, możesz automatycznie utworzyć pakiet NuGet podczas kompilowania rozwiązania, dodając kilka dodatkowych właściwości projektu. Dla platform .NET pakiet NuGet musi zawierać zestaw projekcji i zestaw implementacji z komponentu.

Wykonaj poniższe kroki, aby dodać plik specyfikacji NuGet (.nuspec) do projektu SimpleMathProjection .
1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł SimpleMathProjection, wybierz Dodaj>Nowy folder i nadaj folderowi nazwę nuget.
2. Kliknij prawym przyciskiem myszy folder nuget , wybierz polecenie Dodaj>nowy element, wybierz pozycję Plik XML i nadaj mu nazwę SimpleMathProjection.nuspec.
W Eksplorator rozwiązań kliknij dwukrotnie węzeł SimpleMathProjection aby otworzyć plik projektu w edytorze. Dodaj następującą grupę właściwości do teraz otwartego pliku SimpleMathProjection.csproj (bezpośrednio po dwóch istniejących PropertyGroup elementach), aby automatycznie wygenerować pakiet. Te właściwości określają NuspecFile i katalog do wygenerowania pakietu NuGet.
```
<PropertyGroup>
  <GeneratedNugetDir>.\nuget\</GeneratedNugetDir>
  <NuspecFile>$(GeneratedNugetDir)SimpleMathProjection.nuspec</NuspecFile>
  <OutputPath>$(GeneratedNugetDir)</OutputPath>
  <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
Uwaga / Notatka

Jeśli wolisz generować pakiet oddzielnie, możesz również uruchomić nuget.exe narzędzie z poziomu wiersza polecenia. Aby uzyskać więcej informacji na temat tworzenia pakietu NuGet, zobacz Tworzenie pakietu przy użyciu interfejsu wiersza polecenia nuget.exe.

Otwórz plik SimpleMathProjection.nuspec , aby edytować właściwości tworzenia pakietu, a następnie wklej następujący kod. Poniższy fragment kodu jest przykładem specyfikacji NuGet do dystrybucji simpleMathComponent do wielu platform docelowych. Należy pamiętać, że zestaw projekcji, SimpleMathProjection.dll, jest określony zamiast SimpleMathComponent.winmd dla lib\net6.0-windows10.0.19041.0\SimpleMathProjection.dlldocelowego . To zachowanie jest nowe w .NET 6 i nowszych i jest włączone przez język C#/WinRT. Zestaw implementacji, SimpleMathComponent.dll, musi być również dystrybuowany i zostanie załadowany w czasie wykonywania.

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
  <metadata>
    <id>SimpleMathComponent</id>
    <version>0.1.0-prerelease</version>
    <authors>Contoso Math Inc.</authors>
    <description>A simple component with basic math operations</description>
    <dependencies>
      <group targetFramework="net6.0-windows10.0.19041.0" />
      <group targetFramework=".NETCoreApp3.0" />
      <group targetFramework="UAP10.0" />
      <group targetFramework=".NETFramework4.6" />
    </dependencies>
  </metadata>
  <files>
    <!--Support .NET 6, .NET Core 3, UAP, .NET Framework 4.6, C++ -->
    <!--Architecture-neutral assemblies-->
    <file src="..\..\_build\AnyCPU\Release\SimpleMathProjection\bin\SimpleMathProjection.dll" target="lib\net6.0-windows10.0.19041.0\SimpleMathProjection.dll" />
    <file src="..\..\_build\x64\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.winmd" target="lib\netcoreapp3.0\SimpleMathComponent.winmd" />
    <file src="..\..\_build\x64\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.winmd" target="lib\uap10.0\SimpleMathComponent.winmd" />
    <file src="..\..\_build\x64\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.winmd" target="lib\net46\SimpleMathComponent.winmd" />
    <!--Architecture-specific implementation DLLs should be copied into RID-relative folders-->
    <file src="..\..\_build\x64\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.dll" target="runtimes\win10-x64\native\SimpleMathComponent.dll" />
    <!--To support x86 and Arm64, build SimpleMathComponent for those other architectures and uncomment the entries below.-->
    <!--<file src="..\..\_build\Win32\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.dll" target="runtimes\win10-x86\native\SimpleMathComponent.dll" />-->
    <!--<file src="..\..\_build\arm64\Release\SimpleMathComponent\bin\SimpleMathComponent\SimpleMathComponent.dll" target="runtimes\win10-arm64\native\SimpleMathComponent.dll" />-->
  </files>
</package>

Uwaga / Notatka

SimpleMathComponent.dll, zestaw implementacji dla składnika, jest specyficzny dla architektury. Jeśli obsługujesz inne platformy (na przykład x86 lub Arm64), musisz najpierw skompilować SimpleMathComponent dla docelowych platform i dodać te pliki binarne do odpowiedniego katalogu względnego RID. Moduł projekcji SimpleMathProjection.dll i składnik SimpleMathComponent.winmd są neutralne pod względem architektury.

Zapisz i zamknij właśnie edytowane pliki.

Tworzenie rozwiązania w celu wygenerowania projekcji i pakietu NuGet

Przed utworzeniem rozwiązania sprawdź ustawienia Configuration Manager w Visual Studio w obszarze Build>Configuration Manager. W tym przewodniku ustaw Konfiguracja na wydanie i Platforma na x64 dla rozwiązania.

Teraz możesz skompilować rozwiązanie. Kliknij prawym przyciskiem myszy węzeł rozwiązania i wybierz Skompiluj rozwiązanie. Najpierw skompiluje projekt SimpleMathComponent, a następnie projekt SimpleMathProjection. Składnik WinMD i zestaw implementacji (SimpleMathComponent.winmd i SimpleMathComponent.dll), pliki źródłowe projekcji i zestaw projekcji (SimpleMathProjection.dll) zostaną wygenerowane w katalogu danych wyjściowych _build . Zobaczysz również wygenerowany pakiet NuGet SimpleMathComponent0.1.0-prerelease.nupkg w folderze \SimpleMathProjection\nuget .

Ważne

Jeśli którykolwiek z wymienionych powyżej plików nie zostanie wygenerowany, skompiluj rozwiązanie po raz drugi. Może być również konieczne zamknięcie i ponowne otwarcie rozwiązania przed ponownym skompilowaniem.

Może zajść konieczność zamknięcia i ponownego otwarcia rozwiązania, aby element .nupkg pojawił się w Visual Studio, jak pokazano (lub po prostu wybierz opcję Pokaż wszystkie pliki, a następnie ją odznacz).

Eksplorator rozwiązań pokazujący generowanie projekcji

Odwoływanie się do pakietu NuGet w konsolowej aplikacji .NET 6 w języku C#

Aby użyć SimpleMathComponent z projektu .NET, możesz po prostu dodać do nowego projektu .NET odwołanie do pakietu NuGet SimpleMathComponent0.1.0-prerelease.nupkg, który utworzyliśmy w poprzedniej sekcji. Poniższe kroki pokazują, jak to zrobić, tworząc prostą aplikację konsolową w osobnym rozwiązaniu.

Wykonaj poniższe kroki, aby utworzyć nowe rozwiązanie zawierające projekt aplikacji konsolowej języka C# (utworzenie tego projektu w nowym rozwiązaniu umożliwia niezależne przywrócenie pakietu NuGet SimpleMathComponent ).

Ważne

Utworzymy ten nowy projekt Console App w folderze \CsWinRT\src\Samples\NetProjectionSample, który znajdziesz w pobranej lub sklonowanej wersji przykładu projekcji C#/WinRT.
1. W nowym wystąpieniu Visual Studio wybierz Plik>Nowy>Project.
2. W oknie dialogowym Tworzenie nowego projektu, wyszukaj szablon projektu Aplikacja konsolowa. Wybierz szablon projektu języka C#, który jest nazywany po prostu aplikacją konsolową (bez prefiksów ani sufiksów), a następnie kliknij przycisk Dalej. Jeśli używasz Visual Studio 2019 r., szablon projektu to Console Application.
3. Nadaj nowemu projektowi nazwę SampleConsoleApp, ustaw jego lokalizację na ten sam \CsWinRT\src\Samples\NetProjectionSample folder, w który znajdują się foldery SimpleMathComponent i SimpleMathProjection , a następnie kliknij przycisk Dalej.
4. Na stronie Dodaj informacje wybierz .NET 8.0 (obsługa długoterminowa) a następnie wybierz pozycję Utwórz.
W Eksplorator rozwiązań, kliknij dwukrotnie węzeł SampleConsoleApp, aby otworzyć plik SampleConsoleApp.csproj, a następnie zmodyfikuj właściwości TargetFramework i Platform tak, aby wyglądały jak na poniższej liście. Dodaj element Platform, jeśli go tam nie ma.
```
<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>net6.0-windows10.0.19041.0</TargetFramework>
  <Platform>x64</Platform>
</PropertyGroup>
```
Gdy plik projektu SampleConsoleApp.csproj jest nadal otwarty, dodamy do projektu SampleConsoleApp referencję do pakietu NuGet SimpleMathComponent. Aby przywrócić SimpleMathComponent NuGet podczas kompilowania projektu, możesz użyć właściwości RestoreSources, podając ścieżkę do folderu nuget w rozwiązaniu komponentu. Skopiuj następującą konfigurację i wklej ją do SampleConsoleApp.csproj (wewnątrz elementu Project).
```
<PropertyGroup>
  <RestoreSources>
    https://api.nuget.org/v3/index.json;
    ../SimpleMathProjection/nuget
  </RestoreSources>
</PropertyGroup>

<ItemGroup>
  <PackageReference Include="SimpleMathComponent" Version="0.1.0-prerelease" />
</ItemGroup>
```
Ważne

Ścieżka RestoreSources dla pakietu SimpleMathComponent jest ustawiona na ../SimpleMathProjection/nuget. Ta ścieżka jest poprawna, jeśli wykonano kroki opisane w tym przewodniku, tak że projekty SimpleMathComponent i SampleConsoleApp znajdują się w tym samym folderze (w tym przypadku NetProjectionSample folderze). Jeśli zrobiłeś coś innego, musisz odpowiednio dostosować ścieżkę. Alternatywnie możesz dodać lokalne repozytorium pakietów NuGet do rozwiązania.

Edytuj plik Program.cs , aby korzystać z funkcji udostępnianych przez aplikację SimpleMathComponent.

var x = new SimpleMathComponent.SimpleMath();
Console.WriteLine("Adding 5.5 + 6.5 ...");
Console.WriteLine(x.add(5.5, 6.5).ToString());

Zapisz i zamknij właśnie edytowane pliki, a następnie skompiluj i uruchom aplikację konsolową. Powinny zostać wyświetlone dane wyjściowe poniżej.

Znane problemy

Podczas tworzenia projektu projekcji może zostać wyświetlony błąd, taki jak: Error MSB3271 Wystąpiła niezgodność architektury procesora projektu tworzonego "MSIL" i architektury procesora "x86" pliku implementacji "..\SimpleMathComponent.dll" dla "..\SimpleMathComponent.winmd". Ta niezgodność może spowodować błędy środowiska uruchomieniowego. Rozważ zmianę docelowej architektury procesora projektu za pomocą Menedżera konfiguracji, aby dopasować architekturę procesora między projektem a plikiem implementacji lub wybierz plik winmd z plikiem implementacji, który ma architekturę procesora zgodną z docelową architekturą procesora projektu. Aby obejść ten błąd, dodaj następującą właściwość do pliku projektu biblioteki C#:
```
<PropertyGroup>
    
    <ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>None</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
</PropertyGroup>
```

Dalsze zagadnienia

Projekcja (lub międzyoperacyjność) w języku C#, o której pokazaliśmy, jak ją utworzyć w tym temacie, jest dość prosta — nie ma zależności od innych składników. Jednak aby wygenerować projekcję języka C# dla składnika C++/WinRT, który zawiera odwołania do typów Zestaw SDK do aplikacji systemu Windows, w projekcie projekcji należy dodać odwołanie do pakietu NuGet Zestaw SDK do aplikacji systemu Windows. Jeśli brakuje takich odwołań, zobaczysz błędy, takie jak "Nie można odnaleźć typu <T> ".

Inną rzeczą, którą robimy w tym temacie, jest dystrybuowanie projekcji jako pakietu NuGet. Ta jest obecnie wymagana.

Zasoby

Pełny przykład kodu dla tego przewodnika
dokumentacja C#/WinRT NuGet
NuGet.exe dokumentacji

Opinia

Czy ta strona była pomocna?

Last updated on 2026-04-14