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

C#/WinRT consente agli sviluppatori di usare .NET per 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, consultare l'esempio di authoring C#/WinRT. Per altre informazioni sulla creazione, vedere Componenti di creazione.

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

Prerequisiti

Questa procedura dettagliata richiede gli strumenti e i componenti seguenti:

Visual Studio 2022
.NET 6.0 SDK o versione successiva
VSIX C++/WinRT per i modelli di progetto C++/WinRT

Creare un semplice componente Windows Runtime usando C#/WinRT

Per iniziare, creare un nuovo progetto in Visual Studio. Seleziona il modello di progetto Libreria di Classi e dai al progetto il nome AuthoringDemo. È necessario apportare le aggiunte e le modifiche seguenti al progetto:

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 di Windows SDK in TFM. Per ulteriori dettagli sulla versione supportata, consulta .NET 6 e versioni successive: usa l'opzione TFM.
Installare il pacchetto NuGet Microsoft.Windows.CsWinRT nel tuo progetto.

a) Nell'Esplora soluzioni, fai clic con il pulsante destro del mouse sul nodo del progetto e seleziona Gestisci pacchetti NuGet.

b. Cercare il pacchetto NuGet Microsoft.Windows.CsWinRT e installare la versione più recente. Questa procedura dettagliata usa C#/WinRT versione 1.4.1.
Aggiungere un nuovo elemento PropertyGroup che imposta la proprietà CsWinRTComponent. Specifica che il progetto è un componente Windows Runtime in modo che venga generato un .winmd file quando si compila il progetto.
```
<PropertyGroup>   
    <CsWinRTComponent>true</CsWinRTComponent>
</PropertyGroup>
```
Per un elenco completo delle proprietà del progetto C#/WinRT, consulta la documentazione NuGet di C#/WinRT.
È possibile scrivere le classi runtime usando i file di classe della libreria .cs. Fare clic con il pulsante destro del Class1.cs mouse sul file 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 progetto per generare il file per il .winmd componente. Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere Compila. 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. Una possibilità alternativa è utilizzare il componente come riferimento di 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 progetto, aggiungere la proprietà seguente al file di progetto AuthoringDemo e quindi ricompilare il progetto.
```
<PropertyGroup>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
In alternativa, è possibile generare un pacchetto NuGet facendo clic con il pulsante destro del mouse sul progetto di AuthoringDemo in Esplora Soluzioni e selezionando l'opzione 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 altri dettagli 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 dalle app C#/.NET è supportato sia dal riferimento al pacchetto che dal 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 di progetto per gli utilizzatori C# richiedono .NET 6.

Aggiungere una nuova progetto di applicazione console C++/WinRT alla soluzione. Si noti che questo progetto può anche far parte di una soluzione diversa, se lo si sceglie.

a) In Esplora soluzioni, fai clic con il pulsante destro del mouse sul nodo della tua soluzione e seleziona Aggiungi ->Nuovo progetto.

b. Nella finestra di dialogo Aggiungi nuovo progetto, cercare il modello di progetto C++/WinRT applicazione console. Selezionare il modello e fare clic su Avanti.

c. Denominare il nuovo progetto CppConsoleApp e fare clic su Crea.
Aggiungere un riferimento al componente AuthoringDemo, come pacchetto NuGet o riferimento a un progetto.
- Opzione 1 (Riferimento pacchetto):
  
  a) Fare clic con il pulsante destro del mouse sul progetto CppConsoleApp e selezionare Gestisci pacchetti NuGet. Potrebbe essere necessario configurare le origini dei pacchetti per aggiungere un riferimento al pacchetto NuGet AuthoringDemo. A tale scopo, cliccare sull'icona impostazioni in Gestione pacchetti NuGet 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.
- Opzione 2 (riferimento al progetto):
  
  a) Clic destro sul progetto CppConsoleApp e selezionare Aggiungi ->Riferimento. Nel nodo Progetti, aggiungere un riferimento al progetto AuthoringDemo.
Per ospitare il componente, è necessario aggiungere un file manifesto per le registrazioni delle classi attivabili. Per ulteriori dettagli 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 progetto 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, l'utente dell'app deve registrare le classi attivabili nel file manifesto del pacchetto Package.appxmanifest, come illustrato in Procedura dettagliata: Creare un componente C# con controlli WinUI 3 e utilizzarlo da un'applicazione Windows App SDK C++.

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

Aprire main.cpp nei File di origine del progetto e sostituirlo con i contenuti seguenti.

#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 progetto CppConsoleApp. Ora dovresti vedere l'output qui sotto.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-08-13