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

2025-06-10

In diesem Thema behandeln wir, wie man mit C#/WinRT eine C# .NET-Projektions- (oder Interop-) Assembly aus einer C++/WinRT-Windows-Runtime-Komponente generiert und sie als NuGet-Paket für .NET-Anwendungen verteilt.

In .NET 6 und höher wird die Verwendung von Windows-Metadatendateien (WinMD) nicht mehr unterstützt (siehe Integrierte Unterstützung für WinRT wird aus .NETentfernt). Stattdessen kann das C#/WinRT-Tool verwendet werden, um eine Projektionsassembly für jede WinMD-Datei zu generieren, die dann die Verwendung von WinRT-Komponenten aus .NET-Anwendungen ermöglicht. Eine Projektionsbaugruppe 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 in einer .NET-Konsolenanwendung.

Voraussetzungen

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

Visual Studio 2022 (oder Visual Studio 2019) mit installiertem Entwicklungs-Workload für die universelle Windows-Plattform. Überprüfen Sie in Installationsdetails>Universal-Windows-Plattform-Entwicklungdie Option C++-(v14x)-Universal-Windows-Plattform-Tools.
.NET 6.0 SDK oder höher.

nur Visual Studio 2019. Die C++/WinRT VSIX-Erweiterung, die Ihnen C++/WinRT-Projektvorlagen in Visual Studio zur Verfügung stellt. Die Projektvorlagen sind in Visual Studio 2022 integriert.

In dieser exemplarischen Vorgehensweise verwenden wir Visual Studio 2022 und .NET 6.

Von Bedeutung

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

Erstellen einer einfachen C++/WinRT-Komponente für Windows-Runtime

Um diesem Leitfaden zu folgen, müssen Sie zunächst eine C++/WinRT-Windows-Runtime-Komponente (WRC) haben, aus der die C#-Projektionsassembly erzeugt wird.

In dieser exemplarischen Vorgehensweise wird die SimpleMathComponent WRC aus dem C#/WinRT-Projektionsbeispiel auf GitHub verwendet, das Sie bereits heruntergeladen oder geklont haben. "SimpleMathComponent" wurde aus der Windows-Runtime-Komponente (C++/WinRT) Visual Studio-Projektvorlage (im Lieferumfang von Visual Studio 2022 oder mit der C++/WinRT VSIX-Erweiterung) erstellt.

Um das SimpleMathComponent Projekt in Visual Studio zu öffnen, öffnen Sie die Datei \CsWinRT\src\Samples\NetProjectionSample\CppWinRTComponentProjectionSample.sln, die Sie in Ihrem Download oder Ihrer Kopie des Repositorys vorfinden.

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 Ja- für das SimpleMathComponent C++/WinRT-Komponentenprojekt für Windows-Runtime festgelegt ist. Legen Sie dazu in den Projekteigenschaften für SimpleMathComponentunter Konfigurationseigenschaften>Allgemein>Projektvorgabendie Eigenschaft Windows Desktop Compatible auf Jafest. Dadurch wird sichergestellt, dass die richtigen Runtime-Binärdateien für die Verwendung von .NET-Desktop-Apps geladen werden.

Desktop-kompatible Eigenschaften-Seite

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 sie einen gültigen WinRT-Klassennamen zurückgeben. Da C#/WinRT den Klassennamen als Zeichenfolge für die Interoperabilität verwendet, löst ein falscher Klassenname zur Laufzeit eine InvalidCastExceptionaus.

Hinzufügen eines Projektionsprojekts zur Komponentenlösung

Entfernen Sie zunächst, wenn die CppWinRTComponentProjectionSample Projektmappe weiterhin in Visual Studio geöffnet ist, das SimpleMathProjection Projekt aus dieser Projektmappe. 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 im Projektmappen-Explorermit der rechten Maustaste auf Ihren Lösungsknoten und klicken Sie auf Neues Projekt hinzufügen>.
2. Geben Sie im Dialogfeld Neues Projekt hinzufügen im Suchfeld Klassenbibliothek ein. Wählen Sie in der Sprachenliste C# und dann Windows aus der Plattformliste aus. Wählen Sie die C#-Projektvorlage aus, die schlicht 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 werden, in dem sich der SimpleMathComponent Ordner befindet. Überprüfen Sie das. Klicken Sie dann auf Weiter.
4. Wählen Sie auf der Seite Zusätzliche Informationen.NET 6.0 (Langfristiger Support)aus, und wählen Sie dann Erstellenaus.
Löschen Sie den Stub Class1.cs Datei aus dem Projekt.
Führen Sie die folgenden Schritte aus, um das C#/WinRT NuGet-Paket zu installieren.
1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Projekt SimpleMathProjection und wählen Sie NuGet-Pakete verwaltenaus.
2. Geben Sie auf der Registerkarte DurchsuchenMicrosoft.Windows.CsWinRT in das Suchfeld ein, wählen Sie in den Suchergebnissen das Element mit der neuesten Version aus, und klicken Sie dann auf Installieren, um das Paket im SimpleMathProjection Projekt zu installieren.
Fügen Sie dem Projekt SimpleMathProjection einen Verweis auf das Projekt SimpleMathComponent hinzu. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf den Knoten Abhängigkeiten unter dem Projektknoten SimpleMathProjection, wählen Sie Projektverweis hinzufügenaus und wählen Sie das Projekt SimpleMathComponent aus. Klicken Sie dann auf >OK.

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

Bisher sollte Ihr Solution Explorer ähnlich aussehen (Ihre Versionsnummern können unterschiedlich sein).

Projektmappen-Explorer mit Projektionsprojektabhängigkeiten

Projekte aus dem Quellcode erstellen

Für die CppWinRTComponentProjectionSample Lösung im C#/WinRT-Projektionsbeispiel (das Sie von GitHub heruntergeladen oder geklont haben und jetzt geöffnet haben), wird der Build-Ausgabeort mit der Datei Directory.Build.props konfiguriert, um außerhalb des Quellverzeichnisseszu erstellen. Das bedeutet, dass Dateien aus dem Build-Ergebnis außerhalb des Quellordners generiert werden. Es wird empfohlen, beim Verwenden des C#/WinRT-Tools aus dem Quellcode zu kompilieren. 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:

Wenn die CppWinRTComponentProjectionSample Lösung weiterhin geöffnet ist, klicken Sie mit der rechten Maustaste auf den Lösungsknoten und wählen Sie Hinzufügen>Neues Elementaus. Wählen Sie das XML-Datei--Element aus und benennen Sie es in Directory.Build.props (ohne eine .xml Erweiterung) um. 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 im Projektmappen-Explorerauf 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. In diesem Beispiel wird die Windows SDK-Version net6.0-windows10.0.19041.0 (auch als Windows 10, Version 2004 bezeichnet) verwendet. Legen Sie das Platform-Element auf AnyCPU- fest, sodass die resultierende Projektionseinheit von jeder App-Architektur aus referenziert werden kann. Um verweisende Anwendungen zur Unterstützung früherer Windows SDK-Versionen zuzulassen, können Sie die TargetPlatformMinimumVersion Eigenschaft auch festlegen.
```
<PropertyGroup>
  <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
  
  <Platform>AnyCPU</Platform>
</PropertyGroup>
```
Hinweis

Für diese Anleitung und den zugehörigen Beispielcode wird die Lösung für x64 und Releaseerstellt. Beachten Sie, dass das Projekt SimpleMathProjection so konfiguriert ist, dass es für AnyCPU in allen Lösungskonfigurationen erstellt wird.
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 eigenschaft CsWinRTIncludes 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 bei Bedarf, um die Projekte erneut zu 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. Das NuGet-Paket muss für .NET-Ziele die Projektionsassembly und die Implementierungsassembly aus der Komponente enthalten.

Führen Sie die folgenden Schritte aus, um dem .nuspec eine NuGet-Spezifikationsdatei () hinzuzufügen.
1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf den knoten SimpleMathProjection, wählen Sie >Neuen Ordner hinzufügenaus, 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 im Projektmappen-Explorerauf den Knoten SimpleMathProjection, um die Projektdatei im Editor zu öffnen. Fügen Sie der jetzt geöffneten SimpleMathProjection.csproj (unmittelbar nach den beiden vorhandenen PropertyGroup Elementen) die folgende Eigenschaftengruppe hinzu, um das Paket automatisch zu generieren. Diese Eigenschaften geben die NuspecFile und das Verzeichnis zur Generierung des NuGet-Pakets an.
```
<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 SimpleMathComponent- an mehrere Zielframeworks. Beachten Sie, dass anstelle von SimpleMathComponent.winmd die Projektionsassembly SimpleMathProjection.dllfür das Ziel lib\net6.0-windows10.0.19041.0\SimpleMathProjection.dllangegeben wird. Dieses Verhalten ist neu in .NET 6 und höher und wird von C#/WinRT aktiviert. Die Implementierungsassembly, 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 Projektionsassembly SimpleMathProjection.dll und die Komponente SimpleMathComponent.winmd sind beide architekturneutral.

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

Bauen Sie die Lösung, um die Projektion und das NuGet-Paket zu generieren.

Stellen Sie vor dem Erstellen der Lösung sicher, dass Sie die Configuration Manager Einstellungen in Visual Studio unter Build>Configuration Managerüberprüfen. Legen Sie für diese exemplarische Vorgehensweise die Configuration auf Release und die Platform auf x64 für die Lösung fest.

Jetzt können Sie die Lösung erstellen. Klicken Sie mit der rechten Maustaste auf den Lösungsknoten, und wählen Sie Build Solutionaus. Dadurch wird zuerst das Projekt "SimpleMathComponent " und dann das Projekt "SimpleMathProjection " erstellt. Die WinMD-Komponente und die Implementierungsassembly (SimpleMathComponent.winmd und SimpleMathComponent.dll), die Projektionsquelldateien und die Projektionsassembly (SimpleMathProjection.dll) werden alle unter dem _build Ausgabeverzeichnis generiert. Sie können auch das generierte NuGet-Paket SimpleMathComponent0.1.0-prerelease.nupkgunter dem ordner \SimpleMathProjection\nuget anzeigen.

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 Lösung auch schließen und erneut öffnen, bevor Sie sie neu kompilieren.

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

Projektmappen-Explorer zeigt Projektionsgenerierung

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

Um SimpleMathComponent aus einem .NET-Projekt zu nutzen, können Sie einfach einem neuen .NET-Projekt 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 diese neue Konsolen-App Projekt im ordner \CsWinRT\src\Samples\NetProjectionSample, die Sie im heruntergeladenen oder Klon des C#/WinRT-Projektionsbeispielsfinden.
1. Wählen Sie in einer neuen Instanz von Visual Studio Datei>Neu>Projektaus.
2. Suchen Sie im Dialogfeld Erstellen eines neuen Projekts nach der Projektvorlage Konsolen-App. Wählen Sie die C#-Projektvorlage aus, die einfach Konsolen-App heißt (ohne Präfixe oder Suffixe), und klicken Sie auf Weiter. Wenn Sie Visual Studio 2019 verwenden, ist die Projektvorlage "Konsolenanwendung".
3. Benennen Sie das neue Projekt SampleConsoleApp, legen Sie den Speicherort auf denselben \CsWinRT\src\Samples\NetProjectionSample Ordner 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 6.0 (Langfristiger Support)aus, und wählen Sie dann Erstellenaus.
Doppelklicken Sie im Projektmappen-Explorerauf den Knoten SampleConsoleApp, um die SampleConsoleApp.csproj Projektdatei zu öffnen, und bearbeiten Sie die Eigenschaften TargetFramework und Platform 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>
```
Wenn die SampleConsoleApp.csproj Projektdatei noch geöffnet ist, fügen wir dem SampleConsoleApp Projekt einen Verweis auf das SimpleMathComponent NuGet-Paket hinzu. Um die SimpleMathComponent NuGet beim Erstellen des Projekts wiederherzustellen, können Sie die RestoreSources-Eigenschaft mit dem Pfad zum Nuget Ordner in Ihrer Komponentenlösung verwenden. Kopieren Sie die folgende Konfiguration, und fügen Sie sie in SampleConsoleApp.csproj (innerhalb des Project Elements) 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/nugetfestgelegt. 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 Lösung 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. Sie sollten die Ausgabe unten sehen.

Bekannte Probleme

Beim Erstellen des Projektionsprojekts wird möglicherweise ein Fehler wie: Fehler MSB3271 Es gab einen Konflikt zwischen der Prozessorarchitektur des Projekts, das "MSIL" und der Prozessorarchitektur "x86" der Implementierungsdatei "." erstellt wurde.\SimpleMathComponent.dll" für ".. \SimpleMathComponent.winmd". Dieser Konflikt kann zu Laufzeitfehlern führen. Sie sollten die zielorientierte Prozessorarchitektur Ihres Projekts über den Configuration Manager ändern, um die Prozessorarchitekturen zwischen Ihrem Projekt und der Implementierungsdatei auszurichten, oder wählen Sie eine winmd-Datei mit einer Implementierungsdatei mit einer Prozessorarchitektur aus, die der zielbezogenen Prozessorarchitektur Ihres Projekts entspricht. Um diesen Fehler zu umgehen, fügen Sie der Projektdatei der C#-Bibliothek 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 zu generieren, die Verweise auf Windows App SDK-Typen enthält, 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. Diese ist derzeit erforderlich.

Freigeben über