Självstudie: Skapa ett .NET-verktyg med hjälp av .NET CLI

Den här artikeln gäller för: ✔️ .NET 8 SDK och senare versioner

I den här handledningen lär du dig hur du skapar och paketerar ett .NET-verktyg. Med .NET CLI kan du skapa ett konsolprogram som ett verktyg, som andra kan installera och köra. .NET-verktyg är NuGet-paket som är installerade från .NET CLI. Mer information om verktyg finns i Översikt över .NET-verktyg.

Verktyget du skapar är ett konsolprogram som tar information om den aktuella .NET miljön och visar den, inklusive .NET version, operativsysteminformation och nyckelmiljövariabelinställningar.

Den här handledningen är den första i en serie av tre handledningar. I den här handledningen skapar och paketar du ett verktyg. I de kommande två självstudierna använder du verktyget som ett globalt verktyg och använder verktyget som ett lokalt verktyg. Procedurerna för att skapa ett verktyg är desamma oavsett om du använder det som ett globalt verktyg eller som ett lokalt verktyg.

Förutsättningar

• .NET SDK 10.0 eller en senare version.

  I den här självstudien används .NET SDK 10.0, men den här guiden gäller för .NET 8.0 och senare.

• Valfri textredigerare eller kodredigerare.

Skapa ett projekt

1. Öppna en kommandotolk och skapa en mapp med namnet repository.

2. Gå till lagringsplatsens mapp och ange följande kommando:

   dotnet new console -n dotnet-env
   

   Kommandot skapar en ny mapp med namnet dotnet-env under lagringsplatsens mapp.

3. Gå till mappen dotnet-env .

   cd dotnet-env
   

Lägg till koden

1. Öppna filen Program.cs med kodredigeraren.

2. Ersätt innehållet med följande kod:

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

   Programmet använder högnivåinstruktioner för att läsa av monteringens informationsversion med Assembly.GetEntryAssembly() och AssemblyInformationalVersionAttribute, och skriver sedan ut appnamnet och en avgränsarrad innan tre informationsavsnitt visas.

   • Runtime – .NET-version, ramverksbeskrivning och körningsmiljöidentifierare använder Environment.Version och RuntimeInformation.
   • System – OS-beskrivning, arkitektur, datornamn och antal processorer.
   • Miljövariabler – sex nyckelvariabler som är relaterade till .NET (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES och DOTNET_ENVIRONMENT), som visar (not set) för alla som inte är konfigurerade.

   Direktivet using System.Reflection krävs för Assembly.GetEntryAssembly() och AssemblyInformationalVersionAttribute. Direktivet using System.Runtime.InteropServices krävs för RuntimeInformation.

3. Spara ändringarna.

Testa programmet

Kör projektet och se utdata:

dotnet run

Utdata ser ut ungefär som i följande exempel:

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)

Paketera verktyget

Om du vill packa och distribuera programmet som ett verktyg ändrar du projektfilen.

1. Öppna filen dotnet-env.csproj och lägg till tre nya XML-noder i slutet av <PropertyGroup> noden:

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

   <ToolCommandName> är ett valfritt element som anger kommandot som anropar verktyget efter installationen. Om det här elementet inte anges är kommandonamnet för verktyget sammansättningsnamnet, vilket vanligtvis är projektfilnamnet utan tillägget .csproj .

   Anmärkning

   Välj ett unikt värde för <ToolCommandName>. Undvik att använda filnamnstillägg (t.ex .exe . eller .cmd) eftersom verktyget är installerat som en appvärd och kommandot inte bör innehålla något tillägg. Detta hjälper till att förhindra konflikter med befintliga kommandon och säkerställer en smidig installation.

   <PackageOutputPath> är ett valfritt element som avgör var .NET skapar NuGet-paketet. .NET CLI använder NuGet-paketet för att installera verktyget.

   Projektfilen ser nu ut som i följande exempel:

   <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. Skapa ett NuGet-paket genom att köra kommandot dotnet pack :

   dotnet pack
   

   Filen dotnet-env.1.0.0.nupkg skapas i mappen som identifieras av <PackageOutputPath> värdet från filen dotnet-env.csproj , som i det här exemplet är mappen ./nupkg .

   Om du vill släppa ett verktyg offentligt laddar du upp det till https://www.nuget.org. När verktyget är tillgängligt på NuGet kan utvecklare installera verktyget med hjälp av installationskommandot för dotnet-verktyget . I den här självstudien installerar du paketet direkt från den lokala nupkg-mappen , så du behöver inte ladda upp paketet till NuGet.

Felsökning

Om du får ett felmeddelande när du följer självstudien kan du läsa Felsöka problem med användning av .NET-verktyg.

Nästa steg

I den här handledningen skapade du ett konsolprogram och paketera det som ett verktyg. För att lära dig använda verktyget globalt, gå vidare till nästa handledning.

Om du vill kan du hoppa över självstudien om globala verktyg och gå direkt till självstudien om lokala verktyg.

Se även

• Skapa RID-specifika och AOT .NET-verktyg