Esercitazione: Creare uno strumento .NET usando l'interfaccia della riga di comando di .NET

Questo articolo si applica a: ✔️ .NET 8 SDK e versioni successive

Questa esercitazione illustra come creare e impacchettare uno strumento .NET. L'interfaccia della riga di comando di .NET consente di creare un'applicazione console come strumento, che altri utenti possono installare ed eseguire. Gli strumenti .NET sono pacchetti NuGet installati dall'interfaccia della riga di comando di .NET. Per altre informazioni sugli strumenti, vedere Panoramica degli strumenti .NET.

Lo strumento che verrà creato è un'applicazione console che accetta informazioni sull'ambiente di .NET corrente e la visualizza, tra cui la versione .NET, i dettagli del sistema operativo e le impostazioni principali delle variabili di ambiente.

Questa esercitazione è la prima di una serie di tre esercitazioni. In questa esercitazione, si crea e si impacchetta uno strumento. Nelle due esercitazioni successive si usa lo strumento come strumento globale e si usa lo strumento come strumento locale. Le procedure per la creazione di uno strumento sono le stesse sia che lo si utilizzi come strumento globale sia come strumento locale.

Prerequisiti

  • .NET SDK 10.0 o versione successiva.

    Questa esercitazione usa .NET SDK 10.0, ma questa guida si applica a .NET 8.0 e versioni successive.

  • Un editor di testo o editor di codice di propria scelta.

Creare un progetto

  1. Aprire un prompt dei comandi e creare una cartella denominata repository.

  2. Passare alla cartella del repository e immettere il comando seguente:

    dotnet new console -n dotnet-env

    Il comando crea una nuova cartella denominata dotnet-env nella cartella del repository .

  3. Passare alla cartella dotnet-env .

    cd dotnet-env

Aggiungi il codice

  1. Aprire il file Program.cs con l'editor di codice.

  2. Sostituire il contenuto con il codice seguente:

    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)"}");
}

    Il programma usa istruzioni di primo livello per leggere la versione informativa dell'assembly usando Assembly.GetEntryAssembly() e AssemblyInformationalVersionAttribute, quindi stampa il nome dell'app e una riga separatore prima di visualizzare tre sezioni di informazioni:

    • Runtime, ovvero la versione .NET, la descrizione del framework e l'identificatore di runtime, usando Environment.Version e RuntimeInformation.
    • Sistema : descrizione del sistema operativo, architettura, nome computer e conteggio del processore.
    • Variabili di ambiente — sei variabili chiave correlate a .NET (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES e DOTNET_ENVIRONMENT), che mostrano (not set) per qualsiasi elemento non configurato.

    La using System.Reflection direttiva è obbligatoria per Assembly.GetEntryAssembly() e AssemblyInformationalVersionAttribute. La using System.Runtime.InteropServices direttiva è obbligatoria per RuntimeInformation.

  3. Salvare le modifiche.

Testare l'applicazione

Eseguire il progetto e visualizzare l'output:

dotnet run

L'output è simile al seguente esempio:

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)

Annotazioni

I valori visualizzati dipendono dal computer e dall'installazione .NET. L'output varia in base alla piattaforma.

Impacchettare lo strumento

Per comprimere e distribuire l'applicazione come strumento, modificare il file di progetto.

  1. Aprire il file dotnet-env.csproj e aggiungere tre nuovi nodi XML alla fine del <PropertyGroup> nodo:

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

    <ToolCommandName> è un elemento facoltativo che specifica il comando che richiama lo strumento dopo l'installazione. Se questo elemento non viene specificato, il nome del comando per lo strumento è il nome dell'assembly, che in genere è il nome del file di progetto senza l'estensione csproj .

    Annotazioni

    Scegliere un valore univoco per <ToolCommandName>. Evitare di usare estensioni di file (ad esempio .exe o .cmd) perché lo strumento è installato come host dell'app e il comando non deve includere un'estensione. In questo modo è possibile evitare conflitti con i comandi esistenti e garantire un'esperienza di installazione senza problemi.

    <PackageOutputPath> è un elemento facoltativo che determina dove .NET produce il pacchetto NuGet. L'interfaccia della riga di comando di .NET usa il pacchetto NuGet per installare lo strumento.

    Il file di progetto è ora simile all'esempio seguente:

    <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. Creare un pacchetto NuGet eseguendo il comando dotnet pack :

    dotnet pack

    Il file dotnet-env.1.0.0.nupkg viene creato nella cartella identificata dal <PackageOutputPath> valore del file dotnet-env.csproj , che in questo esempio è la cartella ./nupkg .

    Per rilasciare pubblicamente uno strumento, caricarlo in https://www.nuget.org. Quando lo strumento è disponibile in NuGet, gli sviluppatori possono installare lo strumento usando il comando dotnet tool install . Per questa esercitazione si installa il pacchetto direttamente dalla cartella nupkg locale, quindi non è necessario caricare il pacchetto in NuGet.

Risoluzione dei Problemi

Se viene visualizzato un messaggio di errore durante l'esercitazione, vedere Risolvere i problemi di utilizzo degli strumenti .NET.

Passaggi successivi

In questo tutorial, hai creato un'applicazione console e l'hai convertita in uno strumento. Per informazioni su come usare lo strumento come strumento globale, passare all'esercitazione successiva.

Installare e usare uno strumento globale

Se si preferisce, è possibile ignorare l'esercitazione sugli strumenti globali e passare direttamente all'esercitazione sugli strumenti locali.

Installare e usare uno strumento locale

Vedere anche

  • Last updated on