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

Artikel
06/24/2023

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

I den här självstudien lär du dig att skapa och paketera 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 installeras från .NET CLI. Mer information om verktyg finns i Översikt över .NET-verktyg.

Verktyget som du skapar är ett konsolprogram som tar ett meddelande som indata och visar meddelandet tillsammans med textrader som skapar bilden av en robot.

Det här är den första i en serie med tre självstudier. I den här självstudien 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 6.0.100 eller senare.

I den här självstudien används .NET SDK 6.0, men globala verktyg är tillgängliga från .NET Core SDK 2.1. Lokala verktyg är tillgängliga från och med .NET Core SDK 3.0.
Valfri textredigerare eller kodredigerare.

Skapa ett projekt

Öppna en kommandotolk och skapa en mapp med namnet repository.
Gå till lagringsplatsens mapp och ange följande kommando:
```
dotnet new console -n microsoft.botsay -f net6.0
```
Kommandot skapar en ny mapp med namnet microsoft.botsay under lagringsplatsens mapp.
Anteckning

I den här självstudien skapar du ett verktyg som är avsett för .NET 6.0. Om du vill rikta ett annat ramverk ändrar du alternativet -f|--framework . Om du vill rikta in flera ramverk ändrar du elementet TargetFramework till ett TargetFrameworks element i projektfilen enligt följande exempel:
```
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworks>net8.0;net6.0</TargetFrameworks>
  </PropertyGroup>
</Project>
```
Gå till mappen microsoft.botsay .
```
cd microsoft.botsay
```

Lägga till koden

Öppna filen Program.cs med kodredigeraren.

Ersätt koden i Program.cs med följande kod:

using System.Reflection;

namespace microsoft.botsay;

internal class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");
    }
}

Direktivet using System.Reflection; krävs av kod som du lägger till i nästa steg.

Main Ersätt metoden med följande kod för att bearbeta kommandoradsargumenten för programmet.

static void Main(string[] args)
{
    if (args.Length == 0)
    {
        var versionString = Assembly.GetEntryAssembly()?
                                .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
                                .InformationalVersion
                                .ToString();

        Console.WriteLine($"botsay v{versionString}");
        Console.WriteLine("-------------");
        Console.WriteLine("\nUsage:");
        Console.WriteLine("  botsay <message>");
        return;
    }

    ShowBot(string.Join(' ', args));
}

Om inga argument skickas visas ett kort hjälpmeddelande. Annars sammanfogas alla argument till en enda sträng och skrivs ut genom att anropa den ShowBot metod som du skapar i nästa steg.

Lägg till en ny metod med namnet ShowBot som tar en strängparameter. Metoden skriver ut meddelandet och en bild av en robot med hjälp av textrader.

static void ShowBot(string message)
{
    string bot = $"\n        {message}";
    bot += @"
    __________________
                      \
                       \
                          ....
                          ....'
                           ....
                        ..........
                    .............'..'..
                 ................'..'.....
               .......'..........'..'..'....
              ........'..........'..'..'.....
             .'....'..'..........'..'.......'.
             .'..................'...   ......
             .  ......'.........         .....
             .    _            __        ......
            ..    #            ##        ......
           ....       .                 .......
           ......  .......          ............
            ................  ......................
            ........................'................
           ......................'..'......    .......
        .........................'..'.....       .......
     ........    ..'.............'..'....      ..........
   ..'..'...      ...............'.......      ..........
  ...'......     ...... ..........  ......         .......
 ...........   .......              ........        ......
.......        '...'.'.              '.'.'.'         ....
.......       .....'..               ..'.....
   ..       ..........               ..'........
          ............               ..............
         .............               '..............
        ...........'..              .'.'............
       ...............              .'.'.............
      .............'..               ..'..'...........
      ...............                 .'..............
       .........                        ..............
        .....
";
    Console.WriteLine(bot);
}

Spara ändringarna.

Testa programmet

Kör projektet och se utdata. Prova de här varianterna på kommandoraden för att se olika resultat:

dotnet run
dotnet run -- "Hello from the bot"
dotnet run -- Hello from the bot

Alla argument efter att avgränsare -- har skickats till ditt program.

Paketera verktyget

Innan du kan packa och distribuera programmet som ett verktyg måste du ändra projektfilen.

Öppna filen microsoft.botsay.csproj och lägg till tre nya XML-noder i slutet av <PropertyGroup> noden:
```
<PackAsTool>true</PackAsTool>
<ToolCommandName>botsay</ToolCommandName>
<PackageOutputPath>./nupkg</PackageOutputPath>
```
<ToolCommandName> är ett valfritt element som anger kommandot som anropar verktyget när det har installerats. Om det här elementet inte anges är kommandonamnet för verktyget sammansättningsnamnet, vilket vanligtvis är projektfilnamnet utan .csproj-tillägget .

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

Projektfilen ser nu ut som i följande exempel:
```
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>

    <PackAsTool>true</PackAsTool>
    <ToolCommandName>botsay</ToolCommandName>
    <PackageOutputPath>./nupkg</PackageOutputPath>

  </PropertyGroup>

</Project>
```
Skapa ett NuGet-paket genom att köra kommandot dotnet pack :
```
dotnet pack
```
Filen microsoft.botsay.1.0.0.nupkg skapas i mappen som identifieras av <PackageOutputPath> värdet från filen microsoft.botsay.csproj , som i det här exemplet är mappen ./nupkg .

När du vill släppa ett verktyg offentligt kan du ladda 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öka

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

Nästa steg

I den här självstudien skapade du ett konsolprogram och paketerade det som ett verktyg. Om du vill lära dig hur du använder verktyget som ett globalt verktyg går du vidare till nästa självstudie.

Installera och använda ett globalt verktyg

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

Installera och använda ett lokalt verktyg

Dela via