Procedura dettagliata: creare un componente C#/WinRT e usarlo da C++/WinRT

C#/WinRT consente agli sviluppatori di usare .NET di creare i propri componenti Windows Runtime in C# usando un progetto di libreria di classi. I componenti creati possono essere utilizzati nelle applicazioni desktop native come riferimento al pacchetto o come riferimento al progetto con alcune modifiche.

Questa procedura dettagliata illustra come creare un semplice componente Windows Runtime usando C#/WinRT, distribuire il componente come pacchetto NuGet e usare il componente da un'applicazione console C++/WinRT. Per l'esempio completo che fornisce il codice per questo articolo, vedere l'esempio di creazione C#/WinRT. Per ulteriori dettagli sulla creazione di contenuti, vedere Componenti di authoring.

Per una procedura dettagliata sulla creazione di controlli WinUI 3 con C#/WinRT specificamente per l'uso nelle applicazioni SDK per app di Windows, vedere l'articolo Walkthrough: Creare un componente C# con controlli WinUI e usare da un'applicazione SDK per app di Windows C++

Prerequisiti

Questa procedura dettagliata richiede gli strumenti e i componenti seguenti:

Visual Studio 2022 o versione successiva
.NET 8.0 SDK (LTS) o versione successiva
C++/WinRT VSIX per i modelli di project C++/WinRT

Creare un componente Windows Runtime semplice con C#/WinRT

Per iniziare, creare un nuovo progetto in Visual Studio. Selezionare il modello Class Library project e denominare project AuthoringDemo. È necessario apportare le aggiunte e le modifiche seguenti al project:

Aggiornare il TargetFramework nel file AuthoringDemo.csproj e aggiungere gli elementi seguenti al PropertyGroup:
```
<PropertyGroup>
    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
    <Platforms>x64</Platforms>
</PropertyGroup>
```
Per accedere ai tipi di Windows Runtime, è necessario impostare una versione specifica Windows SDK in TFM. Per altre informazioni sulla versione supportata, vedere .NET 6 e versioni successive: Usare l'opzione TFM.
Installare il Microsoft.Windows. CsWinRT pacchetto NuGet nel progetto.

a) In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo del progetto e selezionare Gestisci pacchetti NuGet.

b. Cercare il Microsoft.Windows. CsWinRT pacchetto NuGet e installare la versione più recente.
Aggiungere un nuovo elemento PropertyGroup che imposta la proprietà CsWinRTComponent. Specifica che il progetto è un componente Windows Runtime in modo che venga generato un file .winmd quando si compila il progetto.
```
<PropertyGroup>   
    <CsWinRTComponent>true</CsWinRTComponent>
</PropertyGroup>
```
Per un elenco completo delle proprietà del progetto C#/WinRT, vedere la documentazione di C#/WinRT NuGet.
È possibile scrivere le classi runtime usando i file di classe della libreria .cs. Fare clic con il tasto destro sul file Class1.cs e rinominarlo in Example.cs. Aggiungere il codice seguente a questo file, che aggiunge una proprietà pubblica e un metodo alla classe di runtime. Ricordarsi di contrassegnare tutte le classi che si desidera esporre nel componente di runtime come public.
```
namespace AuthoringDemo
{
    public sealed class Example
    {
        public int SampleProperty { get; set; }

        public static string SayHello()
        {
            return "Hello from your C# WinRT component";
        }
    }
}
```
È ora possibile compilare il project per generare il file .winmd per il componente. Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere Build. Vedrai il file AuthoringDemo.winmd generato nella cartella di output della compilazione.

Generare un pacchetto NuGet per il componente

La maggior parte degli sviluppatori vuole distribuire e condividere il componente Windows Runtime come pacchetto NuGet. Un'altra opzione consiste nell'usare il componente come riferimento del progetto. I passaggi seguenti illustrano come impacchettare il componente AuthoringDemo. Quando si genera il pacchetto, C#/WinRT configura il componente e ospita gli assembly nel pacchetto per abilitare l'utilizzo da applicazioni native.

Esistono diversi modi per generare il pacchetto NuGet:

Se si vuole generare un pacchetto NuGet ogni volta che si compila il project, aggiungere la proprietà seguente al file AuthoringDemo project e quindi ricompilare il project.
```
<PropertyGroup>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
In alternativa, è possibile generare un pacchetto NuGet facendo clic con il pulsante destro del mouse sul progetto AuthoringDemo in Esplora soluzioni e selezionando Pack.

Quando si compila il pacchetto, la finestra compilazione indica che il pacchetto NuGet è stato creato correttamente. Vedere Creare un pacchetto usando l'interfaccia della riga di comando dotnet per altre informazioni sulle proprietà del pacchetto NuGet con l'interfaccia della riga di comando di .NET.

Utilizza il componente in un'app C++/WinRT

I componenti Windows Runtime creati da C#/WinRT possono essere utilizzati da qualsiasi linguaggio compatibile con Windows Runtime (WinRT). I passaggi seguenti illustrano come chiamare il componente creato in precedenza in un'applicazione console C++/WinRT.

Annotazioni

L'utilizzo di un componente C#/WinRT nelle app C#/.NET è supportato sia mediante riferimento al pacchetto che mediante riferimento al progetto. Questo scenario equivale a usare qualsiasi libreria di classi C# normale e non comporta l'attivazione winRT nella maggior parte dei casi. A partire da C#/WinRT 1.3.5, i riferimenti al progetto per gli utilizzatori di C# richiedono .NET 6 o una versione successiva.

Aggiungere un nuovo progetto Applicazione Console C++/WinRT alla soluzione. Si noti che questo progetto può anche far parte di una soluzione diversa se lo scegli.

a) In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo della soluzione e scegliere Aggiungi ->Nuovo Project.

b. Nella finestra di dialogo Aggiungi nuovo Project cercare il modello C++/WinRT Console Application project. Selezionare il modello e fare clic su Avanti.

c. Denominare il nuovo project CppConsoleApp e fare clic su Crea.
Aggiungere un riferimento al componente AuthoringDemo, come pacchetto NuGet o come riferimento al progetto.
- Opzione 1 (Riferimento pacchetto):
  
  a) Fare clic con il pulsante destro del mouse sul CppConsoleApp project e selezionare Gestisci pacchetti NuGet. Potrebbe essere necessario configurare le origini dei pacchetti per aggiungere un riferimento al pacchetto NuGet AuthoringDemo. A tale scopo, fare clic sull'icona Settings in NuGet Gestione pacchetti e aggiungere un'origine del pacchetto al percorso appropriato.
  
  b. Dopo aver configurato le origini del pacchetto, cercare il pacchetto di AuthoringDemo e fare clic su Installa.
- Option 2 (riferimento progetto):
  
  a) Fare clic con il pulsante destro del mouse sul CppConsoleApp project e selezionare Add ->Reference. Nel nodo Projects aggiungere un riferimento al AuthoringDemo project.
Per ospitare il componente, è necessario aggiungere un file manifesto per le registrazioni delle classi attivabili. Per altre informazioni sull'hosting di componenti gestiti, vedere Hosting di componenti gestiti.

a) Per aggiungere il file manifesto, fare di nuovo clic con il pulsante destro del mouse sul project e scegliere Aggiungi -> Nuovo elemento. Cercare il modello file di testo e denominarlo CppConsoleApp.exe.manifest. Incolla i contenuti seguenti, che specificano le classi di runtime usando voci di registrazione per classi attivabili.
```
<?xml version="1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
    <assemblyIdentity version="1.0.0.0" name="CppConsoleApp"/>
    <file name="WinRT.Host.dll">
        <activatableClass
            name="AuthoringDemo.Example"
            threadingModel="both"
            xmlns="urn:schemas-microsoft-com:winrt.v1" />
    </file>
</assembly>
```
Il file manifesto dell'applicazione è necessario per le app non in pacchetto. Per le app in pacchetto, il consumer dell'app deve registrare le classi attivabili nel file manifesto del pacchetto Package.appxmanifest, come illustrato in Walkthrough: Creare un componente C# con controlli WinUI e usarlo da un'applicazione C++ SDK per app di Windows.

b. Modificare il project per includere il file manifesto nell'output durante la distribuzione del project. Fare clic sul file CppConsoleApp.exe.manifest in Esplora soluzioni e impostare la proprietà Content su True. Di seguito è riportato un esempio di questo aspetto.
Aprire pch.h nei file di intestazione del progetto e aggiungere la seguente riga di codice per includere il componente.
```
#include <winrt/AuthoringDemo.h>
```

Aprire main.cpp sotto i file di origine del project e sostituirlo con il contenuto seguente.

#include "pch.h"
#include "iostream"

using namespace winrt;
using namespace Windows::Foundation;

int main()
{
    init_apartment();

    AuthoringDemo::Example ex;
    ex.SampleProperty(42);
    std::wcout << ex.SampleProperty() << std::endl;
    std::wcout << ex.SayHello().c_str() << std::endl;
}

Compilare ed eseguire il CppConsoleApp project. Ora dovresti vedere l'output qui sotto.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-14