Tutoriel : Créer un outil .NET à l’aide de l’interface CLI .NET

Cet article s’applique à : ✔️ .NET 8 SDK et versions ultérieures

Ce tutoriel vous explique comment créer et empaqueter un outil .NET. L’interface CLI .NET vous permet de créer une application console en tant qu’outil, que d’autres peuvent installer et exécuter. Les outils .NET sont des packages NuGet installés à partir de l’interface CLI .NET. Pour plus d’informations sur les outils, consultez la vue d’ensemble des outils .NET.

L'outil que vous allez créer est une application console qui prend des informations sur l'environnement de .NET actuel et l'affiche, y compris la version .NET, les détails du système d'exploitation et les paramètres des variables d'environnement clés.

Ce tutoriel est le premier d’une série de trois didacticiels. Dans ce tutoriel, vous allez créer et empaqueter un outil. Dans les deux didacticiels suivants, vous utilisez l’outil comme outil global et utilisez l’outil comme outil local. Les procédures de création d’un outil sont identiques si vous l’utilisez en tant qu’outil global ou en tant qu’outil local.

Conditions préalables

  • .NET SDK 10.0 ou une version ultérieure.

    Ce tutoriel utilise .NET SDK 10.0, mais ce guide s’applique à .NET 8.0 et versions ultérieures.

  • Un éditeur de texte ou un éditeur de code de votre choix.

Création d’un projet

  1. Ouvrez une invite de commandes et créez un dossier nommé dépôt.

  2. Accédez au dossier du référentiel et entrez la commande suivante :

    dotnet new console -n dotnet-env

    La commande crée un dossier nommé dotnet-env sous le dossier du dépôt .

  3. Accédez au dossier dotnet-env .

    cd dotnet-env

Ajouter le code

  1. Ouvrez le fichier Program.cs avec votre éditeur de code.

  2. Remplacez le contenu par le code suivant :

    using System.Reflection;
using System.Runtime.InteropServices;

var versionString = Assembly.GetEntryAssembly()?
                        .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
                        .InformationalVersion
                        .ToString();

Console.WriteLine($"dotnet-env v{versionString}");
Console.WriteLine(new string('-', 40));

Console.WriteLine();
Console.WriteLine("Runtime");
Console.WriteLine($"  .NET Version          {Environment.Version}");
Console.WriteLine($"  Framework             {RuntimeInformation.FrameworkDescription}");
Console.WriteLine($"  Runtime Identifier    {RuntimeInformation.RuntimeIdentifier}");

Console.WriteLine();
Console.WriteLine("System");
Console.WriteLine($"  OS                    {RuntimeInformation.OSDescription}");
Console.WriteLine($"  Architecture          {RuntimeInformation.OSArchitecture}");
Console.WriteLine($"  Machine Name          {Environment.MachineName}");
Console.WriteLine($"  Processor Count       {Environment.ProcessorCount}");

Console.WriteLine();
Console.WriteLine("Environment Variables");
string[] envVars = { "DOTNET_ROOT", "DOTNET_HOST_PATH",
                        "DOTNET_CLI_HOME", "DOTNET_NOLOGO",
                        "NUGET_PACKAGES", "DOTNET_ENVIRONMENT" };

foreach (string name in envVars)
{
    string? value = Environment.GetEnvironmentVariable(name);
    Console.WriteLine($"  {name,-24}{value ?? "(not set)"}");
}

    Le programme utilise des instructions de niveau supérieur pour lire la version d’information de l’assembly à l’aide de Assembly.GetEntryAssembly() et AssemblyInformationalVersionAttribute, puis imprime le nom de l’application et une ligne de séparation visuelle avant d’afficher trois sections d'information.

    • Runtime : la version .NET, la description du framework et l’identificateur d’exécution, à l’aide de Environment.Version et RuntimeInformation.
    • Système : description du système d’exploitation, architecture, nom de l’ordinateur et nombre de processeurs.
    • variables Environment — six variables clés liées aux .NET (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES et DOTNET_ENVIRONMENT), affichant (not set) pour les autres qui ne sont pas configurés.

    La using System.Reflection directive est requise pour Assembly.GetEntryAssembly() et AssemblyInformationalVersionAttribute. La using System.Runtime.InteropServices directive est requise pour RuntimeInformation.

  3. Enregistrez vos modifications.

Tester l’application

Exécutez le projet et consultez la sortie :

dotnet run

La sortie ressemble à l’exemple suivant :

dotnet-env v1.0.0
----------------------------------------

Runtime
  .NET Version          10.0.4
  Framework             .NET 10.0.4
  Runtime Identifier    win-x64

System
  OS                    Microsoft Windows 10.0.22631
  Architecture          X64
  Machine Name          MY-MACHINE
  Processor Count       16

Environment Variables
  DOTNET_ROOT             (not set)
  DOTNET_HOST_PATH        (not set)
  DOTNET_CLI_HOME         (not set)
  DOTNET_NOLOGO           (not set)
  NUGET_PACKAGES          (not set)
  DOTNET_ENVIRONMENT      (not set)

Remarque

Les valeurs affichées dépendent de votre ordinateur et de l’installation .NET. La sortie varie selon la plateforme.

Empaqueter l’outil

Pour empaquetez et distribuez l’application en tant qu’outil, modifiez le fichier projet.

  1. Ouvrez le fichier dotnet-env.csproj et ajoutez trois nouveaux nœuds XML à la fin du <PropertyGroup> nœud :

    <PackAsTool>true</PackAsTool>
<ToolCommandName>dotnet-env</ToolCommandName>
<PackageOutputPath>./nupkg</PackageOutputPath>

    <ToolCommandName> est un élément facultatif qui spécifie la commande qui appelle l’outil après l’installation. Si cet élément n’est pas fourni, le nom de commande de l’outil est le nom de l’assembly, qui est généralement le nom du fichier projet sans l’extension .csproj .

    Remarque

    Choisissez une valeur unique pour <ToolCommandName>. Évitez d’utiliser des extensions de fichier (comme .exe ou .cmd) car l’outil est installé en tant qu’hôte d’application et que la commande ne doit pas inclure d’extension. Cela permet d’éviter les conflits avec les commandes existantes et garantit une expérience d’installation fluide.

    <PackageOutputPath> est un élément facultatif qui détermine où .NET produit le package NuGet. L’interface CLI .NET utilise le package NuGet pour installer votre outil.

    Le fichier projet ressemble maintenant à l’exemple suivant :

    <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <PackAsTool>true</PackAsTool>
    <ToolCommandName>dotnet-env</ToolCommandName>
    <PackageOutputPath>./nupkg</PackageOutputPath>

  </PropertyGroup>

</Project>

  2. Créez un package NuGet en exécutant la commande dotnet pack :

    dotnet pack

    Le fichier dotnet-env.1.0.0.nupkg est créé dans le dossier identifié par la <PackageOutputPath> valeur du fichier dotnet-env.csproj , qui dans cet exemple est le dossier ./nupkg .

    Pour libérer publiquement un outil, chargez-le sur https://www.nuget.org. Une fois l’outil disponible sur NuGet, les développeurs peuvent installer l’outil à l’aide de la commande dotnet tool install . Pour ce tutoriel, vous installez le package directement à partir du dossier nupkg local. Vous n’avez donc pas besoin de charger le package sur NuGet.

Résolution des problèmes

Si vous recevez un message d’erreur en suivant le didacticiel, consultez Résoudre les problèmes d’utilisation des outils .NET.

Étapes suivantes

Dans ce tutoriel, vous avez créé une application console et l’avez empaquetée en tant qu’outil. Pour savoir comment utiliser l’outil en tant qu’outil global, passez au didacticiel suivant.

Installer et utiliser un outil global

Si vous préférez, vous pouvez ignorer le didacticiel des outils globaux et accéder directement au didacticiel sur les outils locaux.

Installer et utiliser un outil local

Voir aussi

  • Last updated on