Zelfstudie: Een .NET-hulpprogramma maken met behulp van de .NET CLI

Dit artikel is van toepassing op: ✔️ .NET 8 SDK en latere versies

In deze zelfstudie leert u hoe u een .NET-hulpprogramma maakt en verpakt. Met de .NET CLI kunt u een consoletoepassing maken als hulpprogramma, dat anderen kunnen installeren en uitvoeren. .NET-hulpprogramma's zijn NuGet-pakketten die zijn geïnstalleerd vanuit de .NET CLI. Zie het overzicht van .NET-hulpprogramma's voor meer informatie over hulpprogramma's.

Het hulpprogramma dat u maakt, is een consoletoepassing die informatie over de huidige .NET-omgeving gebruikt en deze weergeeft, inclusief de .NET versie, details van het besturingssysteem en de instellingen voor de belangrijkste omgevingsvariabele.

Deze zelfstudie is de eerste in een reeks van drie zelfstudies. In deze zelfstudie maakt en verpakt u een hulpprogramma. In de volgende twee zelfstudies gebruikt u het hulpprogramma als een algemeen hulpprogramma en gebruikt u het hulpprogramma als een lokaal hulpprogramma. De procedures voor het maken van een hulpprogramma zijn hetzelfde, ongeacht of u het gebruikt als een algemeen hulpprogramma of als een lokaal hulpprogramma.

Vereiste voorwaarden

• .NET SDK 10.0 of een latere versie.

  In deze zelfstudie wordt .NET SDK 10.0 gebruikt, maar deze handleiding is van toepassing op .NET 8.0 en hoger.

• Een teksteditor of code-editor naar keuze.

Een project maken

1. Open een opdrachtprompt en maak een map met de naam opslagplaats.

2. Navigeer naar de repository map en voer de volgende opdracht in:

   dotnet new console -n dotnet-env
   

   Met de opdracht maakt u een nieuwe map met de naam dotnet-env onder de map opslagplaats .

3. Navigeer naar de map dotnet-env.

   cd dotnet-env
   

Code toevoegen

1. Open het Program.cs-bestand met de code-editor.

2. Vervang de inhoud door de volgende code:

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

   Het programma gebruikt instructies op het hoogste niveau om met Assembly.GetEntryAssembly() en AssemblyInformationalVersionAttribute de informatieve versie van de assembly te lezen, waarna de naam van de app en een scheidingslijn worden afgedrukt voordat er drie secties met informatie worden weergegeven.

   • Runtime: de .NET versie, frameworkbeschrijving en runtime-id, met behulp van Environment.Version en RuntimeInformation.
   • Systeem : beschrijving van het besturingssysteem, architectuur, computernaam en processoraantal.
   • Omgevingsvariabelen : zes belangrijke variabelen .NET-gerelateerde variabelen (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES en DOTNET_ENVIRONMENT), met (not set) voor een die niet is geconfigureerd.

   De using System.Reflection richtlijn is vereist voor Assembly.GetEntryAssembly() en AssemblyInformationalVersionAttribute. De using System.Runtime.InteropServices richtlijn is vereist voor RuntimeInformation.

3. Sla uw wijzigingen op.

De toepassing testen

Voer het project uit en bekijk de uitvoer:

dotnet run

De uitvoer ziet er ongeveer als volgt uit:

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)

Het hulpprogramma verpakken

Als u de toepassing wilt inpakken en distribueren als hulpprogramma, wijzigt u het projectbestand.

1. Open het bestand dotnet-env.csproj en voeg drie nieuwe XML-knooppunten toe aan het einde van het <PropertyGroup> knooppunt:

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

   <ToolCommandName> is een optioneel element dat de opdracht aanroept die het hulpprogramma na de installatie aanroept. Als dit element niet is opgegeven, is de opdrachtnaam voor het hulpprogramma de assemblynaam. Dit is meestal de naam van het projectbestand zonder de extensie .csproj .

   Opmerking

   Kies een unieke waarde voor <ToolCommandName>. Vermijd het gebruik van bestandsextensies (zoals .exe of .cmd) omdat het hulpprogramma is geïnstalleerd als een app-host en de opdracht geen extensie mag bevatten. Dit helpt conflicten met bestaande opdrachten te voorkomen en zorgt voor een soepele installatie.

   <PackageOutputPath> is een optioneel element dat bepaalt waar .NET het NuGet-pakket produceert. De .NET CLI gebruikt het NuGet-pakket om uw hulpprogramma te installeren.

   Het projectbestand ziet er nu uit zoals in het volgende voorbeeld:

   <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. Maak een NuGet-pakket door de opdracht dotnet pack uit te voeren:

   dotnet pack
   

   Het bestand dotnet-env.1.0.0.nupkg wordt gemaakt in de map die wordt geïdentificeerd door de <PackageOutputPath> waarde van het bestand dotnet-env.csproj , in dit voorbeeld de map ./nupkg .

   Als u een hulpprogramma openbaar wilt vrijgeven, uploadt u het naar https://www.nuget.org. Zodra het hulpprogramma beschikbaar is in NuGet, kunnen ontwikkelaars het hulpprogramma installeren met behulp van de opdracht dotnet tool install . Voor deze zelfstudie installeert u het pakket rechtstreeks vanuit de lokale nupkg-map, dus u hoeft het pakket niet te uploaden naar NuGet.

Problemen oplossen

Als u een foutbericht krijgt tijdens het volgen van de zelfstudie, raadpleegt u Problemen met het gebruik van .NET-hulpprogramma's oplossen.

Volgende stappen

In deze zelfstudie hebt u een consoletoepassing gemaakt en deze verpakt als een hulpprogramma. Als u wilt weten hoe u het hulpprogramma als een algemeen hulpprogramma gebruikt, gaat u verder met de volgende zelfstudie.

Als u wilt, kunt u de zelfstudie over globale hulpprogramma's overslaan en rechtstreeks naar de zelfstudie met lokale hulpprogramma's gaan.

Zie ook

• RID-specifieke en AOT .NET-hulpprogramma's maken