Lernprogramm: Erstellen eines .NET-Tools mithilfe der .NET CLI

Dieser Artikel gilt für: ✔️ .NET 8 SDK und höhere Versionen

In diesem Lernprogramm erfahren Sie, wie Sie ein .NET-Tool erstellen und verpacken. Mit der .NET CLI können Sie eine Konsolenanwendung als Tool erstellen, die andere installieren und ausführen können. .NET-Tools sind NuGet-Pakete, die über die .NET CLI installiert werden. Weitere Informationen zu Tools finden Sie in der Übersicht über .NET-Tools.

Das Tool, das Sie erstellen, ist eine Konsolenanwendung, die Informationen über die aktuelle .NET-Umgebung verwendet und diese anzeigt, einschließlich der .NET Version, Betriebssystemdetails und schlüsseln der Umgebungsvariableneinstellungen.

Dieses Tutorial ist das erste in einer Reihe von drei Tutorials. In diesem Lernprogramm erstellen und verpacken Sie ein Tool. In den nächsten beiden Lernprogrammen verwenden Sie das Tool als globales Tool und verwenden das Tool als lokales Tool. Die Verfahren zum Erstellen eines Tools sind identisch, unabhängig davon, ob Sie es als globales Tool oder als lokales Tool verwenden.

Voraussetzungen

  • .NET SDK 10.0 oder höher.

    In diesem Lernprogramm wird .NET SDK 10.0 verwendet, dieses Handbuch gilt jedoch für .NET 8.0 und höher.

  • Ein Text-Editor oder Code-Editor Ihrer Wahl.

Erstellen eines Projekts

  1. Öffnen Sie eine Eingabeaufforderung, und erstellen Sie einen Ordner namens Repository.

  2. Navigieren Sie zum Repositoryordner , und geben Sie den folgenden Befehl ein:

    dotnet new console -n dotnet-env

    Der Befehl erstellt einen neuen Ordner namens dotnet-env unter dem Repositoryordner .

  3. Navigieren Sie zum Dotnet-env-Ordner .

    cd dotnet-env

Hinzufügen des Codes

  1. Öffnen Sie die datei Program.cs mit Ihrem Code-Editor.

  2. Ersetzen Sie den Inhalt durch den folgenden 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)"}");
}

    Das Programm verwendet Anweisungen der obersten Ebene, um die Informationsversion der Assembly zu Assembly.GetEntryAssembly() lesen, und AssemblyInformationalVersionAttributedruckt dann den App-Namen und eine Trennlinie, bevor drei Abschnitte mit Informationen angezeigt werden:

    • Runtime – die .NET Version, Frameworkbeschreibung und Laufzeit-ID mit Environment.Version und RuntimeInformation.
    • System – Betriebssystembeschreibung, Architektur, Computername und Prozessoranzahl.
    • Umgebungsvariablen – sechs wichtige .NET-Variablen (DOTNET_ROOT, DOTNET_HOST_PATH, DOTNET_CLI_HOME, DOTNET_NOLOGO, NUGET_PACKAGES und DOTNET_ENVIRONMENT), wobei (not set) für alle angezeigt wird, die nicht konfiguriert sind.

    Die using System.Reflection Richtlinie ist erforderlich für Assembly.GetEntryAssembly() und AssemblyInformationalVersionAttribute. Die using System.Runtime.InteropServices Richtlinie ist erforderlich für RuntimeInformation.

  3. Speichern Sie Ihre Änderungen.

Testen der Anwendung

Führen Sie das Projekt aus, und sehen Sie sich die Ausgabe an:

dotnet run

Die Ausgabe sieht etwa folgendermaßen aus:

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)

Hinweis

Die angezeigten Werte hängen von Ihrem Computer und .NET Installation ab. Die Ausgabe variiert je nach Plattform.

Packen des Tools

Um die Anwendung als Tool zu packen und zu verteilen, ändern Sie die Projektdatei.

  1. Öffnen Sie die Datei dotnet-env.csproj , und fügen Sie am Ende des <PropertyGroup> Knotens drei neue XML-Knoten hinzu:

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

    <ToolCommandName> ist ein optionales Element, das den Befehl angibt, der das Tool nach der Installation aufruft. Wenn dieses Element nicht angegeben wird, ist der Befehlsname für das Tool der Assemblyname, der typischerweise dem Projektdateinamen ohne die Erweiterung .csproj entspricht.

    Hinweis

    Wählen Sie einen eindeutigen Wert für <ToolCommandName>. Vermeiden Sie die Verwendung von Dateierweiterungen (z .exe . B. oder .cmd), da das Tool als App-Host installiert ist und der Befehl keine Erweiterung enthalten sollte. Dadurch werden Konflikte mit vorhandenen Befehlen verhindert und eine reibungslose Installation sichergestellt.

    <PackageOutputPath> ist ein optionales Element, das bestimmt, wo .NET das NuGet-Paket erzeugt. Die .NET CLI verwendet das NuGet-Paket, um Ihr Tool zu installieren.

    Die Projektdatei sieht nun wie im folgenden Beispiel aus:

    <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. Erstellen Sie ein NuGet-Paket, indem Sie den Befehl "dotnet pack " ausführen:

    dotnet pack

    Die datei dotnet-env.1.0.0.nupkg wird im Ordner erstellt, der durch den <PackageOutputPath> Wert aus der Datei dotnet-env.csproj identifiziert wird, was in diesem Beispiel der Ordner "./nupkg " ist.

    Um ein Tool öffentlich freizugeben, laden Sie es in https://www.nuget.org. Sobald das Tool auf NuGet verfügbar ist, können Entwickler das Tool mithilfe des Installationsbefehls des dotnet-Tools installieren . Für dieses Lernprogramm installieren Sie das Paket direkt aus dem lokalen nupkg-Ordner , sodass es nicht erforderlich ist, das Paket in NuGet hochzuladen.

Fehlersuche

Wenn beim Folgen des Lernprogramms eine Fehlermeldung angezeigt wird, lesen Sie die Problembehandlung bei der Verwendung von .NET-Tools.

Nächste Schritte

In diesem Lernprogramm haben Sie eine Konsolenanwendung erstellt und als Tool verpackt. Um zu erfahren, wie Sie das Tool als globales Tool verwenden, wechseln Sie zum nächsten Lernprogramm.

Installieren und Verwenden eines globalen Tools

Wenn Es Ihnen lieber ist, können Sie das Lernprogramm für globale Tools überspringen und direkt zum lernprogramm für lokale Tools wechseln.

Installieren und Verwenden eines lokalen Tools

Siehe auch

  • Last updated on