Procédure pas à pas : créer un composant C#/WinRT et l’utiliser à partir de C++/WinRT

C#/WinRT permet aux développeurs qui utilisent .NET de créer leurs propres composants Windows Runtime en C# à l’aide d’un projet de bibliothèque de classes. Les composants créés peuvent être utilisés dans les applications de bureau natives en tant que référence de package ou en tant que référence de projet avec quelques modifications.

Cette procédure pas à pas montre comment créer un composant Windows Runtime simple à l’aide de C#/WinRT, distribuer le composant en tant que package NuGet et utiliser le composant à partir d’une application console C++/WinRT. Pour obtenir l’exemple complet qui fournit le code de cet article, consultez l’exemple de création C#/WinRT. Pour plus d’informations sur la création, consultez Composants de création.

Pour obtenir une procédure pas à pas sur la création de contrôles WinUI avec C#/WinRT spécifiquement pour une utilisation dans les applications du Kit de développement logiciel (SDK) d’application Windows, reportez-vous à l’article Procédure pas à pas : Créer un composant C# avec des contrôles WinUI et utiliser à partir d’une application sdk d’application Windows C++

Prerequisites

Cette procédure pas à pas nécessite les outils et composants suivants :

Visual Studio 2022
Sdk .NET 6.0 ou version ultérieure
Modèles de projet VSIX C++/WinRT pour C++/WinRT

Créer un composant Windows Runtime simple à l’aide de C#/WinRT

Commencez par créer un projet dans Visual Studio. Sélectionnez le modèle de projet Bibliothèque de classes et nommez le projet AuthoringDemo. Vous devez apporter les ajouts et modifications suivants au projet :

Mettez à jour le TargetFramework fichier AuthoringDemo.csproj et ajoutez les éléments suivants au PropertyGroupfichier :
```
<PropertyGroup>
    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
    <Platforms>x64</Platforms>
</PropertyGroup>
```
Pour accéder aux types Windows Runtime, vous devez définir une version spécifique du Kit de développement logiciel (SDK) Windows dans le module TFM. Pour plus d’informations sur la version prise en charge, consultez .NET 6 et versions ultérieures : utilisez l’option TFM.
Installez le package NuGet Microsoft.Windows.CsWinRT dans votre projet.

a. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet, puis sélectionnez Gérer les packages NuGet.

b. Recherchez le package NuGet Microsoft.Windows.CsWinRT et installez la dernière version. Cette procédure pas à pas utilise C#/WinRT version 1.4.1.
Ajoutez un nouvel PropertyGroup élément qui définit la CsWinRTComponent propriété. Cela spécifie que votre projet est un composant Windows Runtime afin qu’un .winmd fichier soit généré lorsque vous générez le projet.
```
<PropertyGroup>   
    <CsWinRTComponent>true</CsWinRTComponent>
</PropertyGroup>
```
Pour obtenir la liste complète des propriétés du projet C#/WinRT, reportez-vous à la documentation NuGet C#/WinRT.
Vous pouvez créer vos classes runtime à l’aide de fichiers de classe de bibliothèque .cs . Cliquez avec le bouton droit sur le fichier, puis renommez-le Class1.csExample.cs. Ajoutez le code suivant à ce fichier, qui ajoute une propriété publique et une méthode à la classe runtime. N’oubliez pas de marquer les classes que vous souhaitez exposer dans le composant runtime en tant que public.
```
namespace AuthoringDemo
{
    public sealed class Example
    {
        public int SampleProperty { get; set; }

        public static string SayHello()
        {
            return "Hello from your C# WinRT component";
        }
    }
}
```
Vous pouvez maintenant compiler le projet pour générer le fichier .winmd de votre composant. Cliquez avec le bouton droit sur le projet dans l’Explorateur de solutions, puis cliquez sur Générer. Vous verrez le fichier généré AuthoringDemo.winmd dans votre dossier de sortie de build.

Générer un package NuGet pour le composant

La plupart des développeurs souhaitent distribuer et partager leur composant Windows Runtime en tant que package NuGet. Une autre option consiste à utiliser le composant comme référence de projet. Les étapes suivantes montrent comment empaqueter le composant AuthoringDemo . Lorsque vous générez le package, C#/WinRT configure les assemblys de composant et d’hébergement dans le package pour activer la consommation à partir d’applications natives.

Il existe plusieurs façons de générer le package NuGet :

Si vous souhaitez générer un package NuGet chaque fois que vous générez le projet, ajoutez la propriété suivante au fichier projet AuthoringDemo , puis régénérez le projet.
```
<PropertyGroup>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
Vous pouvez également générer un package NuGet en cliquant avec le bouton droit sur le projet AuthoringDemo dans l’Explorateur de solutions et en sélectionnant Pack.

Lorsque vous générez le package, la fenêtre Build doit indiquer que le package AuthoringDemo.1.0.0.nupkg NuGet a été créé avec succès. Pour plus d’informations sur les propriétés du package NuGet avec l’interface CLI .NET, consultez Créer un package à l’aide de l’interface CLI dotnet .

Utiliser le composant depuis une application C++/WinRT

Les composants Windows Runtime créés par C#/WinRT peuvent être consommés à partir de n’importe quel langage compatible Windows Runtime (WinRT). Les étapes suivantes montrent comment appeler le composant créé ci-dessus dans une application console C++/WinRT.

Note

Utiliser un composant C#/WinRT à partir d'applications C#/.NET est possible à l'aide d'une référence de package ou d'une référence de projet. Ce scénario équivaut à consommer une bibliothèque de classes C# ordinaire et n’implique pas l’activation de WinRT dans la plupart des cas. À compter de C#/WinRT 1.3.5, les références de projet pour les consommateurs C# nécessitent .NET 6.

Ajoutez un nouveau projet d’application console C++/WinRT à votre solution. Notez que ce projet peut également faire partie d’une autre solution si vous le choisissez.

a. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur votre nœud de solution, puis cliquez sur Ajouter un>nouveau projet.

b. Dans la boîte de dialogue Ajouter un nouveau projet, recherchez le modèle de projet Application console C++/WinRT . Sélectionnez le modèle, puis cliquez sur Suivant.

c. Nommez le nouveau projet CppConsoleApp , puis cliquez sur Créer.
Ajoutez une référence au composant AuthoringDemo, en tant que package NuGet ou référence de projet.
- Option 1 (référence du package) :
  
  a. Cliquez avec le bouton droit sur le projet CppConsoleApp , puis sélectionnez Gérer les packages NuGet. Vous devrez peut-être configurer vos sources de package pour ajouter une référence au package NuGet AuthoringDemo. Pour ce faire, cliquez sur l’icône Paramètres dans le Gestionnaire de package NuGet et ajoutez une source de package au chemin approprié.
  
  b. Après avoir configuré vos sources de package, recherchez le package AuthoringDemo , puis cliquez sur Installer.
- Option 2 (référence du projet) :
  
  a. Cliquez avec le bouton droit sur le projet CppConsoleApp , puis sélectionnez Ajouter ->Reference. Sous le nœud Projets , ajoutez une référence au projet AuthoringDemo .
Pour héberger le composant, vous devez ajouter un fichier manifeste pour les inscriptions de classes pouvant être activées. Pour plus d’informations sur l’hébergement de composants managés, consultez Hébergement de composants managés.

a. Pour ajouter le fichier manifeste, cliquez avec le bouton droit sur le projet, puis choisissez Ajouter -> Nouvel élément. Recherchez le modèle fichier texte et nommez-le CppConsoleApp.exe.manifest. Collez le contenu suivant, qui spécifie les classes runtime à l’aide d’entrées d’inscription de classes pouvant être activées :
```
<?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>
```
Le fichier manifeste de l’application est requis pour les applications qui ne sont pas empaquetées. Pour les applications empaquetées, le consommateur de l’application doit inscrire les classes pouvant être activées dans son Package.appxmanifest fichier manifeste de package, comme expliqué dans Procédure pas à pas : créer un composant C# avec des contrôles WinUI et consommer à partir d’une application sdk d’application Windows C++.

b. Modifiez le projet pour inclure le fichier manifeste dans la sortie lors du déploiement du projet. Cliquez sur le fichier .manifestCppConsoleApp.exe dans l’Explorateur de solutions et définissez la propriété Contenu sur True. Voici un exemple de ce que cela ressemble.
Ouvrez pch.h sous les fichiers d’en-tête du projet et ajoutez la ligne de code suivante pour inclure votre composant.
```
#include <winrt/AuthoringDemo.h>
```

Ouvrez main.cpp sous les fichiers sources du projet et remplacez-le par le contenu suivant.

#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;
}

Générez et exécutez le projet CppConsoleApp . Vous devriez maintenant voir le résultat ci-dessous.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-12