Condividi tramite

Creazione di un componente Windows Runtime C# da usare da un'app C++/WinRT

Questo argomento illustra il processo di aggiunta di un semplice componente C# al progetto C++/WinRT.

Visual Studio semplifica la creazione e la distribuzione di tipi Windows Runtime personalizzati all'interno di un progetto WRC (Windows Runtime Component) scritto con C# o Visual Basic e quindi di fare riferimento a tale WRC da un progetto di applicazione C++ e di utilizzare tali tipi personalizzati da tale applicazione.

Internamente, i tipi di Windows Runtime possono usare qualsiasi funzionalità .NET consentita in un'applicazione UWP.

Annotazioni

Per altre info, vedi componenti Windows Runtime con C# e Visual Basic epanoramica di .NET per le app UWP.

Esternamente, i membri del tipo possono esporre solo i tipi Windows Runtime per i relativi parametri e valori restituiti. Quando si compila la soluzione, Visual Studio compila il progetto WRC .NET e quindi esegue un passaggio di compilazione che crea un file di metadati windows (con estensione winmd). Si tratta del componente Windows Runtime (WRC), che Visual Studio include nella tua app.

Annotazioni

.NET esegue automaticamente il mapping di alcuni tipi .NET di uso comune, ad esempio tipi di dati primitivi e tipi di raccolta, agli equivalenti di Windows Runtime. Questi tipi .NET possono essere usati nell'interfaccia pubblica di un componente Windows Runtime e vengono visualizzati agli utenti del componente come tipi di Windows Runtime corrispondenti. Vedere componenti Windows Runtime con C# e Visual Basic.

Prerequisiti

Creare un'app vuota

In Visual Studio, crea un nuovo progetto usando il modello di progetto App vuota (C++/WinRT). Assicurati di utilizzare il modello (C++/WinRT) e non quello (Windows Universale).

Impostare il nome del nuovo progetto su CppToCSharpWinRT in modo che la struttura di cartelle corrisponda alla guida dettagliata.

Aggiungere un componente Windows Runtime C# alla soluzione

In Visual Studio, creare il progetto componente: in Esplora Soluzioni aprire il menu di scelta rapida per la soluzione CppToCSharpWinRT e scegliere Aggiungi, e quindi scegliere Nuovo Progetto per aggiungere un nuovo progetto C# alla soluzione. Nella sezione modelli installati della finestra di dialogo Aggiungi nuovo progetto, scegliere Visual C#, e quindi scegliere Windowse quindi Universale. Scegliere il modello di componente Windows Runtime (Windows universale) e immettere sampleComponent per il nome del progetto.

Annotazioni

Nella finestra di dialogo "Nuovo progetto Piattaforma universale Windows", scegliere come versione minima "Windows 10 Creators Update (10.0, Build 15063)". Per ulteriori informazioni, vedere di seguito la sezione Versione Minima dell'Applicazione.

Aggiungere il metodo C# GetMyString

Nel progetto SampleComponent, modificare il nome della classe da Class1 a Esempio. Aggiungere quindi due membri semplici alla classe, un campo int privato e un metodo di istanza denominato GetMyString:

    public sealed class Example
    {
        int MyNumber;

        public string GetMyString()
        {
            return $"This is call #: {++MyNumber}";
        }
    }

Annotazioni

Per impostazione predefinita, la classe è contrassegnata come public sealed. Tutte le classi di Windows Runtime esposte dal componente devono essere sealed.

Annotazioni

Facoltativo: per abilitare IntelliSense per i membri appena aggiunti, in Esplora soluzioni, aprite il menu di scelta rapida per il progetto SampleComponent e selezionate Compila.

Fare riferimento a C# SampleComponent dal progetto CppToCSharpWinRT

In Esplora soluzioni, nel progetto C++/WinRT, aprire il menu di scelta rapida per Riferimentie quindi scegliere Aggiungi Riferimento per aprire la finestra di dialogo Aggiungi Riferimento. Scegliere Progettie quindi scegliere Soluzione. Selezionare la casella di controllo per il progetto SampleComponent e scegliere OK per aggiungere un riferimento.

Annotazioni

Facoltativo: per abilitare IntelliSense per il progetto C++/WinRT, in Esplora Soluzioni aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e quindi scegliere Compila.

Modificare MainPage.h

Aprire MainPage.h nel progetto CppToCSharpWinRT e quindi aggiungere due elementi. Aggiungere prima #include "winrt/SampleComponent.h" alla fine delle dichiarazioni #include, quindi un campo winrt::SampleComponent::Example alla struttura MainPage.

// MainPage.h
...
#include "winrt/SampleComponent.h"

namespace winrt::CppToCSharpWinRT::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
...
        winrt::SampleComponent::Example myExample;
...
    };
}

Annotazioni

In Visual Studio MainPage.h è elencato in MainPage.xaml.

Modifica MainPage.cpp

In MainPage.cpp, modificare l'implementazione di Mainpage::ClickHandler per chiamare il metodo C# GetMyString.

void MainPage::ClickHandler(IInspectable const&, RoutedEventArgs const&)
{
    //myButton().Content(box_value(L"Clicked"));

    hstring myString = myExample.GetMyString();

    myButton().Content(box_value(myString));
}

Eseguire il progetto

È ora possibile compilare ed eseguire il progetto. Ogni volta che si fa clic sul pulsante, il numero nel pulsante verrà incrementato.

screenshot di Windows C++/WinRT che chiama un componente C#

Suggerimento

In Visual Studio, creare il progetto componente: in Esplora soluzioni, aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e scegliere Proprietà, quindi scegliere Debug sotto Proprietà di configurazione. Impostare il tipo di debugger su nativo e gestito se si vuole eseguire il debug sia del codice C++ (nativo) che del codice C# (gestito). Proprietà di debug C++

Versione minima dell'applicazione

L'applicazione minima della versione del progetto di C# controllerà la versione di .NET usata per compilare l'applicazione. Ad esempio, scegliendo Windows 10 Fall Creators Update (10.0; Build 16299) o versioni successive abiliterà il supporto del processore .NET Standard 2.0 e Windows Arm64.

Suggerimento

È consigliabile usare versioni minime dell'applicazione inferiori a 16299 per evitare una configurazione di compilazione aggiuntiva se non è necessario il supporto di .NET Standard 2.0 o Arm64.

Configurare per Windows 10 Fall Creators Update (10.0; Build 16299)

Seguire questa procedura per abilitare il supporto di .NET Standard 2.0 o Windows Arm64 nei progetti C# a cui si fa riferimento dal progetto C++/WinRT.

In Visual Studio, passare all'Esplora soluzioni e aprire il menu di scelta rapida per il progetto CppToCSharpWinRT. Scegli Proprietà e imposta la versione minima dell'applicazione Universale di Windows su Windows 10 Fall Creators Update (10.0; Build 16299) (o versione successiva). Eseguire la stessa operazione per il progetto SampleComponent.

In Visual Studio aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e scegliere Scarica progetto per aprire nell'editor di testo.

Copiare e incollare il codice XML seguente nel primo PropertyGroup in CPPWinRTCSharpV2.vcxproj.

   <!-- Start Custom .NET Native properties -->
   <DotNetNativeVersion>2.2.12-rel-31116-00</DotNetNativeVersion>
   <DotNetNativeSharedLibrary>2.2.8-rel-31116-00</DotNetNativeSharedLibrary>
   <UWPCoreRuntimeSdkVersion>2.2.14</UWPCoreRuntimeSdkVersion>
   <!--<NugetPath>$(USERPROFILE)\.nuget\packages</NugetPath>-->
   <NugetPath>$(ProgramFiles)\Microsoft SDKs\UWPNuGetPackages</NugetPath>
   <!-- End Custom .NET Native properties -->

I valori per DotNetNativeVersion, DotNetNativeSharedLibrarye UWPCoreRuntimeSdkVersion possono variare a seconda della versione di Visual Studio. Per impostarli sui valori corretti, aprire il %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages e controllare la sottodirectory per ogni valore riportato nella tabella sottostante. La directory %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages\Microsoft.Net.Native.Compiler avrà una sottodirectory contenente una versione installata di .NET native che inizia con 2.2. Nell'esempio seguente, è 2.2.12-rel-31116-00.

Variabile MSBuild Directory Esempio
DotNetNativeVersion %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages\Microsoft.Net.Native.Compiler 2.2.12-rel-31116-00
DotNetNativeSharedLibrary %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages\runtime.win10-x64.microsoft.net.native.sharedlibrary 2.2.8-rel-31116-00
UWPCoreRuntimeSdkVersion %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages\Microsoft.Net.UWPCoreRuntimeSdk 2.2.14

Annotazioni

Sono disponibili più architetture supportate per Microsoft.Net.Native.SharedLibrary. Sostituisci x64 con l'architettura appropriata. Ad esempio, l'architettura arm64 si trova nella directory %ProgramFiles(x86)%\Microsoft SDKs\UWPNuGetPackages\runtime.win10-arm64.microsoft.net.native.sharedlibrary.

Successivamente, subito dopo la prima PropertyGroup, aggiungere quanto segue (non modificato).

  <!-- Start Custom .NET Native targets -->
  <!-- Import all of the .NET Native / CoreCLR props at the beginning of the project -->
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\Microsoft.Net.UWPCoreRuntimeSdk.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-x86.Microsoft.Net.UWPCoreRuntimeSdk.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-x64.Microsoft.Net.UWPCoreRuntimeSdk.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-arm.Microsoft.Net.UWPCoreRuntimeSdk.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\Microsoft.Net.Native.Compiler.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-x86.Microsoft.Net.Native.Compiler.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-x64.Microsoft.Net.Native.Compiler.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-arm.Microsoft.Net.Native.Compiler.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm64.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-arm64.Microsoft.Net.Native.Compiler.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-x86.Microsoft.Net.Native.SharedLibrary.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-x64.Microsoft.Net.Native.SharedLibrary.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-arm.Microsoft.Net.Native.SharedLibrary.props" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm64.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-arm64.Microsoft.Net.Native.SharedLibrary.props" />
  <!-- End Custom .NET Native targets -->

Alla fine del file di progetto, subito prima del tag Project di chiusura, aggiungere quanto segue (non modificato).

  <!-- Import all of the .NET Native / CoreCLR targets at the end of the project -->
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-x86.Microsoft.Net.UWPCoreRuntimeSdk.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-x64.Microsoft.Net.UWPCoreRuntimeSdk.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.UWPCoreRuntimeSdk\$(UWPCoreRuntimeSdkVersion)\build\runtime.win10-arm.Microsoft.Net.UWPCoreRuntimeSdk.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\Microsoft.Net.Native.Compiler.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-x86.Microsoft.Net.Native.Compiler.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-x64.Microsoft.Net.Native.Compiler.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-arm.Microsoft.Net.Native.Compiler.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm64.Microsoft.Net.Native.Compiler\$(DotNetNativeVersion)\build\runtime.win10-arm64.Microsoft.Net.Native.Compiler.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x86.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-x86.Microsoft.Net.Native.SharedLibrary.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-x64.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-x64.Microsoft.Net.Native.SharedLibrary.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-arm.Microsoft.Net.Native.SharedLibrary.targets" />
  <Import Condition="'$(WindowsTargetPlatformMinVersion)' &gt;= '10.0.16299.0'" Project="$(NugetPath)\runtime.win10-arm64.Microsoft.Net.Native.SharedLibrary\$(DotNetNativeSharedLibrary)\build\runtime.win10-arm64.Microsoft.Net.Native.SharedLibrary.targets" />
  <!-- End Custom .NET Native targets -->

Ricaricare il file di progetto in Visual Studio. A tale scopo, in Esplora soluzioni di Visual Studio, aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e scegliere Ricarica progetto.

Compilazione per .NET Native

È consigliabile compilare e testare l'applicazione con il componente C# compilato in .NET native. In Visual Studio aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e scegliere Scarica progetto per aprire nell'editor di testo.

Impostare quindi la proprietà UseDotNetNativeToolchain su true nelle configurazioni Release e Arm64 nel file di progetto C++.

In Esplora soluzioni di Visual Studio aprire il menu di scelta rapida per il progetto CppToCSharpWinRT e scegliere Ricarica progetto.

  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
...
    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Platform)'=='Arm64'" Label="Configuration">
    <UseDotNetNativeToolchain Condition="'$(UseDotNetNativeToolchain)'==''">true</UseDotNetNativeToolchain>
  </PropertyGroup>

Riferimento ad altri pacchetti NuGet C#

Se il componente C# fa riferimento ad altri pacchetti nuget , il file di progetto dell'applicazione potrebbe richiedere dipendenze di file di elenco dal pacchetto nuget come contenuto di distribuzione. Ad esempio, se il componente C# fa riferimento al pacchetto nuget Newtonsoft.Json, è necessario fare riferimento anche allo stesso pacchetto NuGet e alla stessa dipendenza di file nel progetto dell'applicazione.

Nel file SampleComponent.csproj aggiungere il riferimento al pacchetto nuget:

    <PackageReference Include="Newtonsoft.Json">
      <Version>13.0.1</Version>
    </PackageReference>

Nel progetto CppToCSharpWinRT individuare il file packages.config e aggiungere il riferimento NuGet appropriato. Verrà installato il pacchetto nuget nella cartella del pacchetto della soluzione.

In packages.configaggiungere lo stesso riferimento al pacchetto NuGet:

  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="native" developmentDependency="true" />

Aggiungere quindi quanto segue al file di progetto dell'applicazione per fare riferimento alla dipendenza appropriata del file dalla cartella del pacchetto della soluzione. Ad esempio, in CppToCSharpWinRT.vcxproj aggiungere quanto segue:

  <ItemGroup>
    <None Include="..\packages\Newtonsoft.Json.13.0.1\lib\netstandard2.0\Newtonsoft.Json.dll">
      <Link>%(Filename)%(Extension)</Link>
      <DeploymentContent>true</DeploymentContent>
    </None>
  </ItemGroup>
  • Last updated on