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

Artikel
09/07/2023

In diesem Thema wird die Verwendung von C#/WinRT zum Generieren einer C# .NET-Projektions (oder Interop)-Assembly aus einer C++/WinRT Windows-Runtime-Komponente und deren Verteilung als NuGet-Paket für .NET-Anwendungen beschrieben.

In .NET 6 und höher wird die Nutzung von Windows-Metadatendateien (WinMD) nicht mehr unterstützt (siehe Integrierte Unterstützung für WinRT wird aus .NET entfernt). Stattdessen kann das C#/WinRT-Tool verwendet werden, um eine Projektions-Assembly für jede WinMD-Datei zu generieren, die dann die Nutzung von WinRT-Komponenten aus .NET-Anwendungen ermöglicht. Eine Projektions-Assembly wird auch als Interop-Assembly bezeichnet. In dieser exemplarischen Vorgehensweise wird Folgendes veranschaulicht:

Verwenden des C#/WinRT-Pakets zum Generieren einer C#-Projektion aus einer C++/WinRT-Komponente.
Verteilen der Komponente zusammen mit der Projektions-Assembly als NuGet Paket.
Nutzen des NuGet-Pakets aus einer .NET-Konsolenanwendung.

Voraussetzungen

Diese exemplarische Vorgehensweise und das entsprechende Beispiel erfordern die folgenden Tools und Komponenten:

Visual Studio 2022 (oder Visual Studio 2019) mit installierter Workload „Entwicklung für die universelle Windows-Plattform“. Aktivieren Sie unter Installationsdetails>Entwicklung für die universelle Windows-Plattform die Tools für Universelle Windows-Plattform – C++ (v14x)-Option(en).
.NET 6.0 SDK oder höher.

Nur Visual Studio 2019. Die C++/WinRT-VSIX-Erweiterung, die Ihnen C++/WinRT-Projektvorlagen in Visual Studio bietet. Die Projektvorlagen sind in Visual Studio 2022 integriert.

Wir verwenden in dieser exemplarischen Vorgehensweise Visual Studio 2022 und .NET 6.

Wichtig

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 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 exemplarischen Vorgehensweise wird die WRC SimpleMathComponent aus dem C#/WinRT-Projektionsbeispiel auf GitHub verwendet, das Sie bereits heruntergeladen oder geklont haben. SimpleMathComponent wurde aus der Visual Studio-Projektvorlage Windows Runtime Component (C++/WinRT) erstellt (die in Visual Studio 2022 oder in der C++/WinRT-VSIX-Erweiterung enthalten ist).

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

Der Code in diesem Projekt stellt die Funktionalität für die grundlegenden mathematischen Operationen zur Verfügung, die in der folgenden Headerdatei gezeigt 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 überprüfen, ob die Windows Desktop Compatible-Eigenschaft für das C++/WinRT-Windows-Runtime-.Komponentenprojekt SimpleMathComponent auf Ja 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 Laufzeitbinärdateien zum Nutzen von .NET-Desktop-Apps geladen werden.

Desktop Compatible property page

Ausführlichere Schritte zum Erstellen einer C++/WinRT-Komponente sowie 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 Komponentenprojektmappe

Entfernen Sie zunächst bei weiterhin in Visual Studio geöffneter CppWinRTComponentProjectionSample-Projektmappe das SimpleMathProjection-Projekt aus dieser Projektmappe. Löschen Sie dann den Ordner SimpleMathProjection von Ihrem Dateisystem (oder benennen Sie ihn gegebenenfalls um). Diese Schritte sind notwendig, damit Sie diese exemplarische Vorgehensweise Schritt für Schritt ausführen können.

Fügen Sie Ihrer Projektmappe ein neues C#-Bibliotheksprojekt hinzu.
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihren Projektmappenknoten, und klicken Sie auf Hinzufügen>Neues Projekt.
2. Geben Sie im Dialogfeld Neues Projekt hinzufügen in das Suchfeld Klassenbibliothek ein. Wählen Sie in der Sprachenliste C# aus, und wählen Sie dann aus der Plattformenliste 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. Nennen 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 die Option .NET 6.0 (langfristige Unterstützung) und anschließend Erstellen aus.
Löschen Sie die Stubdatei Class1.cs aus dem Projekt.
Verwenden Sie die folgenden Schritte, um das C#/WinRT-NuGet-Paket zu installieren.
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr SimpleMathProjection-Projekt, und wählen Sie NuGet-Pakete verwalten aus.
2. Geben oder fügen Sie auf der Registerkarte Durchsuchen den Wert Microsoft.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 SimpleMathProjection-Projekt einen Projektverweis auf das SimpleMathComponent-Projekt hinzu. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten Abhängigkeiten unter dem Projektknoten SimpleMathProjection, wählen Sie Projektverweis hinzufügen, dann das SimpleMathComponent-Projekt und schließlich OK aus.

Versuchen Sie noch nicht, das Projekt zu erstellen. Wir werden dies in einem späteren Schritt tun.

Bis jetzt sollte Ihr Projektmappen-Explorer ungefähr wie dieser aussehen (Ihre Versionsnummern werden abweichen).

Solution Explorer showing projection project dependencies

Erstellen von Projekten außerhalb der Quelle

Für die Projektmappe CppWinRTComponentProjectionSample im C#/WinRT-Projektionsbeispiel (das Sie von GitHub heruntergeladen oder geklont und jetzt geöffnet haben), wird der Speicherort für die Buildausgabe über die Datei Directory.Build.props konfiguriert, um außerhalb der Quelle 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 Stammverzeichnis des Projekts aufsammelt, was zu Fehlern wegen doppelter Typen führen kann (z. B. beim Kompilieren für mehrere Konfigurationen und/oder Plattformen).

Auch wenn dies bereits für die Projektmappe CppWinRTComponentProjectionSample konfiguriert ist, führen Sie die folgenden Schritte aus, um Praxis bei der selbständigen Durchführung der Konfiguration zu bekommen.

So konfigurieren Sie Ihre Projektmappe für die Erstellung außerhalb der Quelle

Bei noch geöffneter Projektmappe CppWinRTComponentProjectionSample klicken Sie mit der rechten Maustaste auf den Projektmappenknoten und wählen 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 folgende 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 Projektions-Assembly zu generieren, müssen Sie zuerst die Projektdatei bearbeiten, um einige Projekteigenschaften anzugeben.

Doppelklicken Sie im Projektmappen-Explorer auf den SimpleMathProjection-Knoten, um die Projektdatei im Editor zu öffnen.
Aktualisieren Sie das TargetFramework-Element so, dass es auf eine bestimmte Windows SDK-Version ausgerichtet ist. Dadurch werden Assemblyabhängigkeiten hinzugefügt, die für die Interop- und Projektionsunterstützung erforderlich sind. Dieses Beispiel ist auf die Windows SDK-Version net6.0-windows10.0.19041.0 (auch als Windows 10, Version 2004, bekannt) ausgerichtet. Legen Sie das Platform-Element auf AnyCPU fest, sodass auf die resultierende Projektionsassembly aus einer beliebigen App-Architektur verwiesen werden kann. Sie können auch die TargetPlatformMinimumVersion-Eigenschaft festlegen, damit verweisende Anwendungen niedrigere Windows SDK-Versionen unterstützen können.
```
<PropertyGroup>
  <TargetFramework>net6.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 SimpleMathProjection-Projekt für AnyCPU für alle Lösungsarchitekturkonfigurationen konfiguriert ist.
Fügen Sie (unmittelbar hinter dem ersten) ein zweites PropertyGroup-Element hinzu, das mehrere C#/WinRT-Eigenschaften festlegt.
```
<PropertyGroup>
  <CsWinRTIncludes>SimpleMathComponent</CsWinRTIncludes>
  <CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
</PropertyGroup>
```
Hier finden Sie 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 ist auf OutDir festgelegt, das in Directory.Build.props aus dem vorangehenden Abschnitt definiert ist.
Speichern und schließen Sie die Datei SimpleMathProjection.csproj, und klicken Sie nötigenfalls auf Projekte neu laden.

Erstellen eines NuGet-Pakets mit der Projektion

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

Verwenden Sie die folgenden Schritte, um dem SimpleMathProjection-Projekt eine NuGet-Spezifikationsdatei (.nuspec) hinzuzufügen.
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten SimpleMathProjection, wählen Sie Hinzufügen>Neuer Ordner aus, und nennen Sie den Ordner nuget.
2. Klicken Sie mit der rechten Maustaste auf den Ordner nuget, wählen Sie Hinzufügen>Neues Element und dann XML-Datei aus, und nennen Sie sie SimpleMathProjection.nuspec.
Doppelklicken Sie im Projektmappen-Explorer auf den SimpleMathProjection-Knoten, 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 es vorziehen, ein Paket separat zu generieren, können Sie das nuget.exe-Tool auch ü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 in .NET 6 und höher neu 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 Implementierungs-Assembly für die Komponente, ist architekturspezifisch. Wenn Sie andere Plattformen (z. B. x86 oder Arm64) unterstützen, müssen Sie zunächst 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

Bevor Sie die Projektmappe erstellen, überprüfen Sie die Konfigurations-Manager-Einstellungen in Visual Studio unter Erstellen>Konfigurations-Manager. Legen Sie für diese exemplarische Vorgehensweise die Konfiguration auf Release und Plattform auf x64 für die Projektmappe fest.

An diesem Punkt können Sie nun die Projektmappe erstellen. Klicken Sie mit der rechten Maustaste auf Ihren Projektmappenknoten, und wählen Sie Projektmappe erstellen aus. Hierdurch wird zuerst das SimpleMathComponent-Projekt erstellt und dann das SimpleMathProjection-Projekt. 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.

Wichtig

Wenn eine der oben genannten Dateien nicht generiert wird, erstellen Sie die Projektmappe 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).

Solution Explorer showing projection generation

Verweisen 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 hierzu vorgehen, indem Sie eine einfache Konsolen-App in einer separaten Projektmappe erstellen.

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

Wichtig

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 Datei>Neu>Projekt 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 (Konsolenanwendung).
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 die Option .NET 6.0 (langfristige Unterstützung) und anschließend Erstellen aus.
Doppelklicken Sie im Projektmappen-Explorer auf den SampleConsoleApp-Knoten, um die SampleConsoleApp.csproj-Projektdatei zu öffnen, und bearbeiten Sie die Eigenschaften TargetFramework und Platform so, dass sie wie im folgenden Listing gezeigt aussehen. Fügen Sie das Platform-Element hinzu, wenn es nicht bereits 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 ein (innerhalb des Project-Elements).
```
<PropertyGroup>
  <RestoreSources>
    https://api.nuget.org/v3/index.json;
    ../SimpleMathProjection/nuget
  </RestoreSources>
</PropertyGroup>

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

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 befolgt, sodass sich die Projekte SimpleMathComponent und SampleConsoleApp im selben Ordner befinden (in diesem Fall der Ordner NetProjectionSample). Wenn Sie etwas anders gemacht haben, müssen Sie diesen Pfad entsprechend anpassen. Alternativ können Sie Ihrer Projektmappe einen lokalen NuGet-Paketfeed hinzufügen.

Bearbeiten Sie die Datei Program.cs so, dass die von SimpleMathComponent bereitgestellte Funktionalität verwendet wird.

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 soeben bearbeiteten Dateien, erstellen Sie die Konsolen-App, und führen Sie sie aus. Die folgende Ausgabe sollte angezeigt werden.

Bekannte Probleme

Beim Erstellen des Projektionsprojekts wird möglicherweise ein Fehler angezeigt wie z. B.: Fehler MSB3271: Konflikt zwischen Prozessorarchitektur des Projekts „MSIL“, das erstellt wird, und der Prozessorarchitektur, „x86“, der Implementierungsdatei „..\SimpleMathComponent.dll“ für „..\SimpleMathComponent.winmd“. Dieser Konflikt kann zu Laufzeitfehlern führen. Ändern Sie ggf. mithilfe des Konfigurations-Managers die als Ziel angegebene Prozessorarchitektur Ihres Projekts so, dass die Prozessorarchitekturen zwischen Ihrem Projekt und der Implementierungsdatei ausgerichtet werden, oder wählen Sie eine WinMD-Datei mit einer Implementierungsdatei aus, die über eine Prozessorarchitektur verfügt, die der als Ziel angegebenen 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 Aspekte

Die C#-Projektionsassembly (oder Interop-Assembly), die wir gezeigt haben, wie sie in diesem Thema erstellt werden können, ist recht einfach – es gibt 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. Das ist derzeit notwendig.