Generieren einer C#-Projektion aus einer C++/WinRT-Komponente, Verteilen als NuGet für .NET-Apps

In diesem Thema führen wir Sie durch die Verwendung von C#/WinRT, um aus einer C++/WinRT-Windows-Runtime-Komponente eine C#-.NET-Projektionsassembly (oder Interop-Assembly) zu generieren und sie als NuGet-Paket für .NET-Anwendungen zu verteilen.

In .NET 6 und höher wird die Nutzung von Windows Metadatendateien (WinMD) nicht mehr unterstützt (siehe Die eingebaute Unterstützung für WinRT wurde aus .NET entfernt). Stattdessen kann das C#/WinRT-Tool verwendet werden, um eine Projektionsassembly für jede WinMD-Datei zu generieren, die dann den Verbrauch von WinRT-Komponenten aus .NET Anwendungen ermöglicht. Eine Projektions-Assembly wird auch als Interop-Assembly bezeichnet. In dieser Schritt-für-Schritt-Anleitung wird gezeigt, wie Sie die folgenden Schritte ausführen:

Verwenden Sie das C#/WinRT-Paket, um eine C#-Projektion aus einer C++/WinRT-Komponente zu generieren.
Verteilen Sie die Komponente zusammen mit der Projektionsassembly als NuGet-Paket.
Verwenden Sie das NuGet-Paket aus einer .NET-Konsolenanwendung.

Voraussetzungen

Für diese Anleitung und das entsprechende Beispiel sind die folgenden Tools und Komponenten erforderlich.

Visual Studio 2022 oder höher mit installiertem Universelle Windows-Plattform Entwicklungsworkload. Überprüfen Sie in Installationsdetails>Universelle Windows-Plattform Development die Option C++ (v14x) Universelle Windows-Plattform Tools.
.NET 8.0 SDK (LTS) oder höher.

In dieser exemplarischen Vorgehensweise verwenden wir Visual Studio 2022 oder höher und .NET 8.

Von Bedeutung

Außerdem müssen Sie den Beispielcode für dieses Thema aus dem C#/WinRT-Projektionsbeispiel für GitHub herunterladen oder klonen. Besuchen Sie CsWinRT, und klicken Sie auf die grüne Schaltfläche Code, um die git clone-URL zu erhalten. Lesen Sie unbedingt die README.md (Infodatei) für das Beispiel.

Erstellen einer einfachen C++/WinRT-Windows-Runtime Komponente

Um dieser exemplarischen Vorgehensweise folgen zu können, müssen Sie zunächst über eine C++/WinRT-Windows-Runtime-Komponente (WRC) verfügen, aus der die C#-Projektions-Assembly generiert werden soll.

In dieser Schritt-für-Schritt-Anleitung wird das SimpleMathComponent WRC aus dem C#/WinRT-Projektionsbeispiel auf GitHub verwendet, das Sie bereits heruntergeladen oder geklont haben. SimpleMathComponent wurde aus der Projektvorlage Windows-Runtime Component (C++/WinRT) Visual Studio erstellt.

Um das Projekt SimpleMathComponent in Visual Studio zu öffnen, öffnen Sie die Datei \CsWinRT\src\Samples\NetProjectionSample\CppWinRTComponentProjectionSample.sln, die Sie im Download oder Klon des Repositorys finden.

Der Code in diesem Projekt stellt die Funktionalität für die grundlegenden mathematischen Vorgänge bereit, die in der Kopfzeilendatei unten angezeigt werden.

// 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);
    };
}

Sie können bestätigen, dass die Windows Desktop Compatible-Eigenschaft auf Yes für das SimpleMathComponent C++/WinRT Windows-Runtime Komponentenprojekt festgelegt ist. Legen Sie hierzu in den Projekteigenschaften für SimpleMathComponent unter Konfigurationseigenschaften>Allgemein>Projektstandards die Eigenschaft Windows Desktop Compatible auf Ja fest. Dadurch wird sichergestellt, dass die richtigen Laufzeit-Binärdateien für den Einsatz in .NET-Desktop-Apps geladen werden.

Eigenschaftenseite „Desktop Compatible“

Ausführlichere Schritte zum Erstellen einer C++/WinRT-Komponente und zum Generieren einer WinMD-Datei finden Sie unter Windows-Runtime-Komponenten mit C++/WinRT.

Hinweis

Wenn Sie IInspectable::GetRuntimeClassName in Ihrer Komponente implementieren, muss ein gültiger WinRT-Klassenname zurückgeben werden. Da C#/WinRT die Klassennamenzeichenfolge für Interop verwendet, löst ein falscher Laufzeitklassenname eine InvalidCastException aus.

Hinzufügen eines Projektionsprojekts zur Komponentenlösung

Entfernen Sie zunächst mit der CppWinRTComponentProjectionSample Lösung, die weiterhin in Visual Studio geöffnet ist, das Projekt SimpleMathProjection aus dieser Lösung. Löschen Sie dann aus Ihrem Dateisystem den Ordner "SimpleMathProjection " (oder benennen Sie ihn bei Bedarf um). Diese Schritte sind erforderlich, damit Sie diese Anleitung Schritt für Schritt verfolgen können.

Fügen Sie Ihrer Lösung ein neues C#-Bibliotheksprojekt hinzu.
1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Lösungsknoten, und klicken Sie auf Add>Neue Project.
2. Geben Sie im Dialogfeld Neues Projekt hinzufügen in das Suchfeld Klassenbibliothek ein. Wählen Sie C# aus der Sprachliste aus, und wählen Sie dann in der Plattformliste Windows aus. Wählen Sie die C#-Projektvorlage aus, die einfach Class Library (Klassenbibliothek) heißt (ohne Präfixe oder Suffixe), und klicken Sie auf Weiter.
3. Benennen Sie das neue Projekt "SimpleMathProjection". Der Speicherort sollte bereits auf denselben \CsWinRT\src\Samples\NetProjectionSample-Ordner festgelegt sein, in dem sich der Ordner SimpleMathComponent befindet. Überprüfen Sie dies jedoch. Klicken Sie dann auf Weiter.
4. Wählen Sie auf der Seite Zusätzliche Informationen.NET 8.0 (Langzeitunterstützung) aus und klicken Sie dann auf Erstellen.
Löschen Sie die Stubdatei Class1.cs aus dem Projekt.
Führen Sie die folgenden Schritte aus, um das C#/WinRT NuGet-Paket zu installieren.
1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf Ihre SimpleMathProjection Projekt, und wählen Sie Manage NuGet Packages aus.
2. Geben Sie auf der Registerkarte BrowseMicrosoft.Windows.CsWinRT in das Suchfeld ein, wählen Sie in den Suchergebnissen das Element mit der neuesten Version aus und klicken Sie dann auf Install, um das Paket im Projekt SimpleMathProjection zu installieren.
Fügen Sie dem Projekt SimpleMathProjection einen Verweis auf das Projekt SimpleMathComponent hinzu. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Knoten Dependencies unter dem SimpleMathProjection-Projektknoten, wählen Sie Projektverweis hinzufügen und wählen Sie das SimpleMathComponent-Projekt aus, und klicken Sie auf >.

Versuchen Sie noch nicht, das Projekt zu erstellen. Dies wird in einem späteren Schritt ausgeführt.

Bisher sollte Ihr Projektmappen-Explorer ähnlich aussehen (Ihre Versionsnummern sind anders).

Projektmappen-Explorer zeigt Abhängigkeiten des Projektionsprojekts

Projekte aus dem Quellcode erstellen

Für die CppWinRTComponentProjectionSample-Lösung im C#/WinRT-Projektion-Beispiel (das Sie von GitHub heruntergeladen oder geklont und jetzt geöffnet haben), wird der Buildausgabespeicherort mit der Datei Directory.Build.props konfiguriert, um außerhalb des Quellverzeichnisses zu erstellen. Dies bedeutet, dass Dateien aus der Buildausgabe außerhalb des Quellordners generiert werden. Es wird empfohlen, bei Verwendung des C#/WinRT-Tools außerhalb der Quelle zu erstellen. Dadurch wird verhindert, dass der C#-Compiler versehentlich alle *.cs Dateien im Projektstammverzeichnis aufnimmt, was zu doppelten Typfehlern führen kann (z. B. beim Kompilieren für mehrere Konfigurationen und/oder Plattformen).

Obwohl dies bereits für die CppWinRTComponentProjectionSample Lösung konfiguriert ist, führen Sie die folgenden Schritte aus, um selbst das Konfigurieren zu üben.

So konfigurieren Sie Ihre Lösung so, dass sie aus der Quelle erstellt wird:

Bei noch geöffneter Lösung CppWinRTComponentProjectionSample klicken Sie mit der rechten Maustaste auf den Projektmappenknoten und wählen Sie Hinzufügen>Neues Element aus. Wählen Sie das Element XML-Datei aus, und nennen Sie es Directory.Build.props (ohne eine .xml-Erweiterung). Klicken Sie auf "Ja ", um die vorhandene Datei zu überschreiben.

Ersetzen Sie den Inhalt von Directory.Build.props durch die nachstehende Konfiguration.

<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>

Speichern und schließen Sie die Datei "Directory.Build.props ".

Bearbeiten der Projektdatei zum Ausführen von C#/WinRT

Bevor Sie das cswinrt.exe-Tool aufrufen können, um die Projektionsbaugruppe zu generieren, müssen Sie zunächst die Projektdatei bearbeiten, um bestimmte Projekteigenschaften anzugeben.

Doppelklicken Sie in Projektmappen-Explorer auf den Knoten SimpleMathProjection, um die Projektdatei im Editor zu öffnen.
Aktualisieren Sie das TargetFramework-Element auf eine bestimmte Windows SDK-Version. Dadurch werden Assemblyabhängigkeiten hinzugefügt, die für die Interop- und Projektionsunterstützung erforderlich sind. Dieses Beispiel zielt auf die Windows SDK-Version net6.0-windows10.0.19041.0 (auch bekannt als Windows 10, Version 2004) ab. Legen Sie das Platform-Element auf AnyCPU fest, sodass auf die resultierende Projektionsassembly aus einer beliebigen App-Architektur verwiesen werden kann. Um verweisenden Anwendungen die Unterstützung früherer Windows SDK-Versionen zu ermöglichen, können Sie auch die Eigenschaft TargetPlatformMinimumVersion festlegen.
```
<PropertyGroup>
  <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
  
  <Platform>AnyCPU</Platform>
</PropertyGroup>
```
Hinweis

Für diese exemplarische Vorgehensweise und den zugehörigen Beispielcode ist die Projektmappe für x64 und Release erstellt worden. Beachten Sie, dass das Projekt SimpleMathProjection so konfiguriert ist, dass es für AnyCPU in allen Lösungskonfigurationen erstellt wird.

Von Bedeutung

Die AnyCPU-Konfiguration in dieser exemplarischen Vorgehensweise gilt für das NuGet-Verteilungsmuster, das weiter unten im Artikel gezeigt wird. Die verwaltete Projektionsassembly ist architekturneutral, während NuGet die native Implementierungs-DLL aus einem architekturspezifischen Laufzeitordner auswählt.

Wenn das Projektionsprojekt <UseUwp>true</UseUwp>verwendet oder anderweitig an MSIX- oder AppX-Paketen teilnimmt und direkt auf das systemeigene C++/WinRT-Projekt verweist, richten Sie sich nicht auf AnyCPU. Konfigurieren Sie die Projektion und native Projekte so, dass sie dieselbe konkrete Plattform wie x86, x64 oder ARM64 verwenden. Erstellen Sie für mehrere Architekturen übereinstimmende Lösungs- und Projektkonfigurationen, und erstellen Sie jede Architektur separat. Andernfalls kann die Paketüberprüfung mit Fehler APPX0505 fehlschlagen, da die neutrale Projektionsarchitektur nicht mit dem systemeigenen Referenzprojekt übereinstimmt.
Fügen Sie ein zweites PropertyGroup Element (unmittelbar nach dem ersten) hinzu, das mehrere C#/WinRT-Eigenschaften festlegt.
```
<PropertyGroup>
  <CsWinRTIncludes>SimpleMathComponent</CsWinRTIncludes>
  <CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
</PropertyGroup>
```
Hier sind einige Details zu den Einstellungen in diesem Beispiel:
- Die CsWinRTIncludes-Eigenschaft gibt an, welche Namespaces projiziert werden sollen.
- Die CsWinRTGeneratedFilesDir Eigenschaft legt das Ausgabeverzeichnis fest, in dem die Projektionsquelldateien generiert werden. Diese Eigenschaft wird auf OutDirfestgelegt, wie in Directory.Build.props im obigen Abschnitt beschrieben.
Speichern und schließen Sie die Datei SimpleMathProjection.csproj, und klicken Sie nötigenfalls auf Projekte neu laden.

Erstellen Sie ein NuGet-Paket mit der Projektion

Um die Projektionsassembly für .NET Anwendungsentwickler zu verteilen, können Sie beim Erstellen der Lösung automatisch ein NuGet-Paket erstellen, indem Sie weitere Projekteigenschaften hinzufügen. Für .NET-Ziele muss das NuGet-Paket die Projektions- und die Implementierungs-Assembly aus der Komponente enthalten.

Führen Sie die folgenden Schritte aus, um dem .nuspec eine NuGet-Spezifikationsdatei () hinzuzufügen.
1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Knoten SimpleMathProjection, wählen Sie Add>Neuer Ordner aus, und benennen Sie den Ordner nuget.
2. Klicken Sie mit der rechten Maustaste auf den Ordner nuget, wählen Sie Neues Element hinzufügen>, wählen Sie XML-Datei, und nennen Sie sie SimpleMathProjection.nuspec.
Doppelklicken Sie in Projektmappen-Explorer auf den Knoten SimpleMathProjection, um die Projektdatei im Editor zu öffnen. Fügen Sie der jetzt geöffneten Datei SimpleMathProjection.csproj (unmittelbar hinter den beiden vorhandenen PropertyGroup-Elementen) die folgende Eigenschaftengruppe hinzu, um das Paket automatisch zu generieren. Diese Eigenschaften geben die NuspecFile und das Verzeichnis an, um das NuGet-Paket zu generieren.
```
<PropertyGroup>
  <GeneratedNugetDir>.\nuget\</GeneratedNugetDir>
  <NuspecFile>$(GeneratedNugetDir)SimpleMathProjection.nuspec</NuspecFile>
  <OutputPath>$(GeneratedNugetDir)</OutputPath>
  <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
Hinweis

Wenn Sie ein Paket separat generieren möchten, können Sie auch das nuget.exe Tool über die Befehlszeile ausführen. Weitere Informationen zum Erstellen eines NuGet-Pakets finden Sie unter Erstellen eines Pakets mithilfe der nuget.exe CLI.

Öffnen Sie die Datei "SimpleMathProjection.nuspec ", um die Paketerstellungseigenschaften zu bearbeiten, und fügen Sie den folgenden Code ein. Der folgende Codeausschnitt ist ein Beispiel für nuGet-Spezifikation zum Verteilen von SimpleMathComponent an mehrere Zielframeworks. Beachten Sie, dass die Projektions-Assembly SimpleMathProjection.dll anstelle von SimpleMathComponent.winmd als Ziel-lib\net6.0-windows10.0.19041.0\SimpleMathProjection.dll angegeben ist. Dieses Verhalten ist neu in .NET 6 und höher und wird von C#/WinRT aktiviert. Die Implementierungs-Assembly SimpleMathComponent.dll muss ebenfalls verteilt werden und wird zur Laufzeit geladen.

<?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>

Hinweis

SimpleMathComponent.dll, die Implementierungsassembly für die Komponente, ist architekturspezifisch. Wenn Sie andere Plattformen (z. B. x86 oder Arm64) unterstützen, müssen Sie zuerst "SimpleMathComponent " für die gewünschten Plattformen erstellen und diese Assemblydateien dem entsprechenden RID-relativen Ordner hinzufügen. Die Projektions-Assembly SimpleMathProjection.dll und die Komponente SimpleMathComponent.winmd sind beide architekturneutral.

Speichern und schließen Sie die Dateien, die Sie gerade bearbeitet haben.

Erstellen der Projektmappe zum Generieren der Projektion und des NuGet-Pakets

Überprüfen Sie vor dem Erstellen der Lösung die Einstellungen Konfigurations-Manager in Visual Studio unter Build>Konfigurations-Manager. Legen Sie für diese exemplarische Vorgehensweise die Konfiguration auf Release und Plattform auf x64 für die Projektmappe fest.

Jetzt können Sie die Lösung erstellen. Klicken Sie mit der rechten Maustaste auf Ihren Projektmappenknoten, und wählen Sie Projektmappe erstellen aus. Dadurch wird zuerst das Projekt "SimpleMathComponent " und dann das Projekt "SimpleMathProjection " erstellt. Die Komponenten-WinMD und Implementierungs-Assembly (SimpleMathComponent.winmd und SimpleMathComponent.dll), die Projektionsquelldateien und die Projektions-Assembly (SimpleMathProjection.dll) werden alle unter dem Ausgabeverzeichnis _build generiert. Das generierte NuGet-Paket SimpleMathComponent0.1.0-prerelease.nupkg wird ebenfalls unter dem Ordner \SimpleMathProjection\nuget angezeigt.

Von Bedeutung

Wenn eine der oben genannten Dateien nicht generiert wird, erstellen Sie die Lösung ein zweites Mal. Möglicherweise müssen Sie die Projektmappe auch schließen und erneut öffnen, bevor Sie sie neu erstellen.

Möglicherweise müssen Sie die Projektmappe schließen und erneut öffnen, damit .nupkg wie dargestellt in Visual Studio angezeigt wird (oder wählen Sie einfach Alle Dateien anzeigen aus, und deaktivieren Sie es dann wieder).

Projektmappen-Explorer mit projektionsgenerierung

Verweisen Sie auf das NuGet-Paket in einer C#-.NET 6-Konsolenanwendung

Um SimpleMathComponent aus einem .NET-Projekt zu nutzen, Sie können einem neuen .NET Projekt einfach einen Verweis auf das SimpleMathComponent0.1.0-prerelease.nupkg NuGet-Paket hinzufügen, das wir im vorherigen Abschnitt erstellt haben. Die folgenden Schritte veranschaulichen, wie Sie dazu eine einfache Konsolen-App in einer separaten Lösung erstellen.

Führen Sie die folgenden Schritte aus, um eine neue Lösung zu erstellen, die ein C#-Konsolen-App-Projekt (--Projekt) enthält (durch das Erstellen dieses Projekts in einer neuen Lösung können Sie das -SimpleMathComponent--NuGet-Paket unabhängig wiederherstellen).

Von Bedeutung

Wir erstellen dieses neue Konsolen-App-Projekt innerhalb des Ordners \CsWinRT\src\Samples\NetProjectionSample, den Sie in ihrem heruntergeladenen oder geklonten C#/WinRT-Projektionsbeispiel finden.
1. Wählen Sie in einer neuen Instanz von Visual Studio File>New>Project aus.
2. Suchen Sie im Dialogfeld Neues Projekt erstellen nach der Projektvorlage Console App. Wählen Sie die C#-Projektvorlage aus, die einfach Console App (Konsolen-App) heißt (ohne Präfixe oder Suffixe), und klicken Sie auf Weiter. Wenn Sie Visual Studio 2019 verwenden, ist die Projektvorlage Console Application.
3. Nennen Sie das neue Projekt SampleConsoleApp, legen Sie seinen Speicherort auf denselben Ordner \CsWinRT\src\Samples\NetProjectionSample fest, in dem sich die Ordner SimpleMathComponent und SimpleMathProjection befinden, und klicken Sie auf Weiter.
4. Wählen Sie auf der Seite Zusätzliche Informationen.NET 8.0 (Langzeitunterstützung) aus und klicken Sie dann auf Erstellen.
In Projektmappen-Explorer, Doppelklicken Sie auf den Knoten SampleConsoleApp, um die Eigenschaften SampleConsoleApp.csproj zu öffnen, und bearbeiten Sie die TargetFramework und Platform Eigenschaften so, dass sie wie in der folgenden Auflistung dargestellt aussehen. Fügen Sie das Platform Element hinzu, wenn es nicht vorhanden ist.
```
<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>net6.0-windows10.0.19041.0</TargetFramework>
  <Platform>x64</Platform>
</PropertyGroup>
```
Als Nächstes fügen wir bei noch geöffneter SampleConsoleApp.csproj-Projektdatei dem SampleConsoleApp-Projekt einen Verweis auf das SimpleMathComponent-NuGet-Paket hinzu. Um das SimpleMathComponent-NuGet-Paket beim Erstellen des Projekts wiederherzustellen, können Sie die RestoreSources-Eigenschaft mit dem Pfad zum Ordner nuget in Ihrer Komponentenprojektmappe verwenden. Kopieren Sie die folgende Konfiguration, und fügen Sie sie in SampleConsoleApp.csproj (innerhalb des elements Project) ein.
```
<PropertyGroup>
  <RestoreSources>
    https://api.nuget.org/v3/index.json;
    ../SimpleMathProjection/nuget
  </RestoreSources>
</PropertyGroup>

<ItemGroup>
  <PackageReference Include="SimpleMathComponent" Version="0.1.0-prerelease" />
</ItemGroup>
```
Von Bedeutung

Der RestoreSources-Pfad für das oben gezeigte SimpleMathComponent-Paket ist auf ../SimpleMathProjection/nuget festgelegt. Dieser Pfad ist richtig, vorausgesetzt, Sie haben die Schritte in dieser exemplarischen Vorgehensweise ausgeführt, sodass sich die SimpleMathComponent- und SampleConsoleApp--Projekte im selben Ordner befinden (in diesem Fall im NetProjectionSample Ordner). Wenn Sie etwas anderes getan haben, müssen Sie diesen Pfad entsprechend anpassen. Alternativ können Sie Ihrer Projektmappe einen lokalen NuGet-Paketfeed hinzufügen.

Bearbeiten Sie die Program.cs Datei, um die von SimpleMathComponent bereitgestellte Funktionalität zu verwenden.

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

Speichern und schließen Sie die Dateien, die Sie gerade bearbeitet haben, und erstellen Sie die Konsolen-App, und führen Sie sie aus. Die folgende Ausgabe sollte angezeigt werden.

Bekannte Probleme

Beim Erstellen des Projektionsprojekts kann möglicherweise ein Fehler auftreten wie: Fehler MSB3271: Es gab einen Konflikt zwischen der Prozessorarchitektur des Projekts „MSIL“ und der Prozessorarchitektur „x86“ der Implementierungsdatei „..\SimpleMathComponent.dll“ für „..\SimpleMathComponent.winmd“. Dieser Konflikt kann zu Laufzeitfehlern führen. Bitte erwägen Sie, die zielgerichtete Prozessorarchitektur Ihres Projekts über den Konfigurations-Manager zu ändern, um die Prozessorarchitektur zwischen Ihrem Projekt und der Implementierungsdatei in Einklang zu bringen, oder wählen Sie eine winmd-Datei mit einer Implementierungsdatei aus, deren Prozessorarchitektur zur zielgerichteten Prozessorarchitektur Ihres Projekts passt. Um diesen Fehler zu beheben, fügen Sie der Projektdatei des C#-Bibliothekprojekts die folgende Eigenschaft hinzu:
```
<PropertyGroup>
    
    <ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>None</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
</PropertyGroup>
```

Weitere Überlegungen

Die C#-Projektionsassembly (oder Interop-Assembly), die wir gezeigt haben, wie man sie in diesem Thema erstellt, ist recht einfach – sie hat keine Abhängigkeiten von anderen Komponenten. Um jedoch eine C#-Projektion für eine C++/WinRT-Komponente mit Verweisen auf Windows App SDK Typen zu generieren, müssen Sie im Projektionsprojekt einen Verweis auf das Windows App SDK NuGet-Paket hinzufügen. Wenn solche Verweise fehlen, werden Fehler wie "Typ <T> konnte nicht gefunden werden" angezeigt.

Eine weitere Vorgehensweise in diesem Thema besteht darin, die Projektion als NuGet-Paket zu verteilen. Das ist derzeit notwendig.

Ressourcen

Feedback

War diese Seite hilfreich?

Last updated on 2026-09-07