Samouczek: tworzenie narzędzia .NET przy użyciu interfejsu wiersza polecenia platformy .NET

Artykuł dotyczy: ✔️ .NET 8 SDK i nowszych wersji

W tym samouczku pokazano, jak utworzyć i spakować narzędzie platformy .NET. Interfejs wiersza polecenia platformy .NET umożliwia utworzenie aplikacji konsolowej jako narzędzia, które inne osoby mogą instalować i uruchamiać. Narzędzia platformy .NET to pakiety NuGet instalowane z poziomu interfejsu wiersza polecenia platformy .NET. Aby uzyskać więcej informacji na temat narzędzi, zobacz Omówienie narzędzi platformy .NET.

Narzędzie, które utworzysz, to aplikacja konsolowa, która pobiera informacje o bieżącym środowisku .NET i wyświetla je, w tym wersję .NET, szczegóły systemu operacyjnego i kluczowe ustawienia zmiennej środowiskowej.

Ten samouczek tutaj jest pierwszym z serii trzech samouczków. W tym samouczku utworzysz i zapakujesz narzędzie. W dwóch następnych samouczkach użyjesz narzędzia jako narzędzia globalnego i użyjesz narzędzia jako narzędzia lokalnego. Procedury tworzenia narzędzia są takie same, niezależnie od tego, czy używasz go jako narzędzia globalnego, czy jako narzędzia lokalnego.

Wymagania wstępne

  • .NET SDK 10.0 lub nowszą.

    Ten samouczek używa .NET SDK 10.0, ale ten przewodnik dotyczy wszystkich wersji .NET od wersji 8.0 wzwyż.

  • Wybrany edytor tekstu lub edytor kodu.

Tworzenie projektu

  1. Otwórz wiersz polecenia i utwórz folder o nazwie repository.

  2. Przejdź do folderu repozytorium i wprowadź następujące polecenie:

    dotnet new console -n dotnet-env

    Polecenie tworzy nowy folder o nazwie dotnet-env w folderze repozytorium .

  3. Przejdź do folderu dotnet-env .

    cd dotnet-env

Dodawanie kodu

  1. Otwórz plik Program.cs za pomocą edytora kodu.

  2. Zastąp zawartość następującym kodem:

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

    Program używa instrukcji najwyższego poziomu do odczytywania wersji informacyjnej zestawu przy użyciu poleceń Assembly.GetEntryAssembly() i AssemblyInformationalVersionAttribute, a następnie wyświetla nazwę aplikacji i wiersz separatora przed wyświetleniem trzech sekcji informacji:

    • Runtime — wersja .NET, opis platformy i identyfikator środowiska uruchomieniowego przy użyciu Environment.Version i RuntimeInformation.
    • System — opis systemu operacyjnego, architektura, nazwa maszyny i liczba procesorów.
    • Zmienne środowiskowe — sześć kluczowych zmiennych związanych z .NET (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES i DOTNET_ENVIRONMENT), pokazując (not set) dla którychkolwiek, które nie są skonfigurowane.

    Dyrektywa using System.Reflection jest wymagana dla Assembly.GetEntryAssembly() i AssemblyInformationalVersionAttribute. using System.Runtime.InteropServices dyrektywa jest wymagana dla RuntimeInformation.

  3. Zapisz zmiany.

Testowanie aplikacji

Uruchom projekt i wyświetl dane wyjściowe:

dotnet run

Dane wyjściowe wyglądają podobnie do następującego przykładu:

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)

Uwaga / Notatka

Wyświetlane wartości zależą od maszyny i .NET instalacji. Dane wyjściowe różnią się w zależności od platformy.

Spakuj narzędzie

Aby spakować i rozpowszechnić aplikację jako narzędzie, zmodyfikuj plik projektu.

  1. Otwórz plik dotnet-env.csproj i dodaj trzy nowe węzły XML na końcu węzła <PropertyGroup> :

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

    <ToolCommandName> jest opcjonalnym elementem określającym polecenie, które wywołuje narzędzie po instalacji. Jeśli ten element nie jest podany, nazwa polecenia narzędzia to nazwa zestawu, która jest zazwyczaj nazwą pliku projektu bez rozszerzenia csproj .

    Uwaga / Notatka

    Wybierz unikatową wartość dla elementu <ToolCommandName>. Unikaj używania rozszerzeń plików (takich jak .exe lub .cmd), ponieważ narzędzie jest zainstalowane jako host aplikacji, a polecenie nie powinno zawierać rozszerzenia. Pomaga to zapobiegać konfliktom z istniejącymi poleceniami i zapewnia bezproblemowe środowisko instalacji.

    <PackageOutputPath> jest opcjonalnym elementem określającym, gdzie .NET tworzy pakiet NuGet. Interfejs wiersza polecenia .NET używa pakietu NuGet do zainstalowania narzędzia.

    Plik projektu wygląda teraz jak w poniższym przykładzie:

    <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. Utwórz pakiet NuGet, uruchamiając polecenie dotnet pack :

    dotnet pack

    Plik dotnet-env.1.0.0.nupkg jest tworzony w folderze zidentyfikowanym przez <PackageOutputPath> wartość z pliku dotnet-env.csproj , który w tym przykładzie jest folderem ./nupkg .

    Aby opublikować narzędzie publicznie, prześlij je do https://www.nuget.org. Gdy narzędzie będzie dostępne w narzędziu NuGet, deweloperzy mogą zainstalować narzędzie za pomocą polecenia dotnet tool install . Na potrzeby tego samouczka zainstalujesz pakiet bezpośrednio z lokalnego folderu nupkg , więc nie ma potrzeby przekazywania pakietu do pakietu NuGet.

Rozwiązywanie problemów

Jeśli podczas wykonywania samouczka zostanie wyświetlony komunikat o błędzie, zobacz Rozwiązywanie problemów z użyciem narzędzi platformy .NET.

Dalsze kroki

W tym samouczku utworzyłeś aplikację konsolową i spakowałeś ją jako narzędzie. Aby dowiedzieć się, jak używać narzędzia jako narzędzia globalnego, przejdź do następnego samouczka.

Instalowanie i używanie narzędzia globalnego

Jeśli wolisz, możesz pominąć samouczek dotyczący narzędzi globalnych i przejść bezpośrednio do samouczka narzędzi lokalnych.

Instalowanie i używanie narzędzia lokalnego

Zobacz także

  • Last updated on