So aktivieren Sie die Tab-Vervollständigung für die .NET CLI

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

In diesem Artikel wird beschrieben, wie Sie den Tababschluss für fünf Shells konfigurieren: PowerShell (pwsh), Bash, zsh, fish und nushell. Für andere Shells lesen Sie deren Dokumentation zur Konfiguration der Tab-Vervollständigung.

Native Shell-Completion-Skripte (.NET 10+)

Ab .NET 10 enthält die .NET CLI systemeigene Shell-Abschlussskripts, die wesentlich schneller ausgeführt werden als die dynamischen Fertigstellungen, die in früheren Versionen verfügbar sind. Systemeigene Fertigstellungen generieren shellspezifische Skripts, die die statischen Teile der CLI-Grammatik direkt in der Shell behandeln und eine erhebliche Leistungsverbesserung bieten.

Generieren von Abschlussskripts

Verwenden Sie den dotnet completions script Befehl, um ein Abschlussskript für Ihre Shell zu generieren:

dotnet completions script [SHELL]

Der [SHELL] Parameter akzeptiert einen der folgenden Werte:

• bash
• fish
• nushell
• pwsh
• zsh

Wenn Sie keine Shell angeben, leitet der Befehl die richtige Shell aus Ihrer Umgebung ab. Unter Windows wird standardmäßig PowerShell (pwsh) verwendet. Auf anderen Systemen wird überprüft, ob der Dateiname der SHELL Umgebungsvariable mit einem der unterstützten Shellwerte übereinstimmt.

Vervollständigungsfunktionen

Systemeigene Fertigstellungen bieten je nach Shell unterschiedliche Unterstützungsebenen:

Shell	Vervollständigungstyp	Beschreibungen in Tab-Vervollständigungen
Bash	hybrid	Nein
Fisch	dynamic	Nein
nushell	dynamic	Nein
PowerShell	hybrid	Yes
zsh	hybrid	Yes

Vervollständigungstypen:

• Hybrid: Generiert shellspezifischen Code, der statische Teile der CLI-Grammatik schnell verarbeitet, aber auf den dotnet complete Befehl für dynamische Inhalte (z. B. NuGet-Paket-IDs) zurückfällt.
• Dynamisch: Alle Fertigstellungen durchlaufen den dotnet complete Befehl, der möglicherweise langsamer ist, aber eine umfassende Abdeckung gewährleistet.

Shells konfigurieren, um native Vervollständigungen zu verwenden.

Fügen Sie den entsprechenden Befehl zum Profil Ihrer Shell hinzu, um systemeigene Fertigstellungen zu ermöglichen:

PowerShell

Fügen Sie Ihrem PowerShell-Profil die folgende Zeile hinzu ($PROFILE):

dotnet completions script pwsh | Out-String | Invoke-Expression

Bash

Fügen Sie die folgende Zeile zu Ihrer .bashrc Datei hinzu:

eval "$(dotnet completions script bash)"

Zsh

Fügen Sie die folgende Zeile zu Ihrer .zshrc Datei hinzu:

eval "$(dotnet completions script zsh)"

Fish

Fügen Sie die folgende Zeile zu Ihrer config.fish Datei hinzu:

dotnet completions script fish | source

Nushell

Fügen Sie am Anfang der config.nu Datei Folgendes hinzu:

dotnet completions script nushell | save -f ~/.local/share/nushell/completions/dotnet.nu
use ~/.local/share/nushell/completions/dotnet.nu *

Dynamische Abschlussskripts (alle Versionen)

Für .NET-Versionen vor .NET 10 oder wenn Sie dynamische Vervollständigungen verwenden möchten, können Sie die Shell so konfigurieren, dass der dotnet complete Befehl verwendet wird. Dynamische Fertigstellungen funktionieren, indem die aktuelle Befehlszeile an den dotnet complete Befehl gesendet und die Ergebnisse in der Shell verarbeitet werden.

Nach der Einrichtung wird der Tab-Abschluss für die .NET CLI ausgelöst, indem ein dotnet Befehl in die Shell eingegeben und dann die TAB-TASTE gedrückt wird. Die aktuelle Befehlszeile wird an den dotnet complete Befehl gesendet, und die Ergebnisse werden von der Shell verarbeitet. Sie können die Ergebnisse testen, ohne die Tab-Vervollständigung zu aktivieren, indem Sie etwas direkt an den dotnet complete Befehl senden. Beispiel:

> dotnet complete "dotnet a"
add
clean
--diagnostics
migrate
pack

Wenn dieser Befehl nicht funktioniert, stellen Sie sicher, dass .NET Core 2.0 SDK oder höher installiert ist. Wenn er installiert ist, dieser Befehl aber immer noch nicht funktioniert, stellen Sie sicher, dass der dotnet Befehl in eine Version von .NET Core 2.0 SDK oder höher aufgelöst wird. Verwenden Sie den Befehl dotnet --version, um festzustellen, in welche Version von dotnet der aktuelle Pfad aufgelöst wird. Weitere Informationen finden Sie unter Auswählen der zu verwendenden .NET-Version.

Beispiele

Hier sind einige Beispiele dafür, was die Tab-Vervollständigung bietet:

Eingabe	Wird zu	Gründe
dotnet a⇥	dotnet add	add ist der erste Unterbefehl alphabetisch.
dotnet add p⇥	dotnet add --help	Bei der Vervollständigung mit der TAB-TASTE werden Teilzeichenfolgen verglichen, und --help ist die erste Übereinstimmung in alphabetischer Reihenfolge.
dotnet add p⇥⇥	dotnet add package	Wenn Sie die TAB-TASTE ein zweites Mal drücken, wird der nächste Vorschlag angezeigt.
dotnet package add Microsoft⇥	dotnet package add Microsoft.ApplicationInsights.Web	Ergebnisse werden alphabetisch zurückgegeben.
dotnet reference remove ⇥	dotnet reference remove ..\..\src\OmniSharp.DotNet\OmniSharp.DotNet.csproj	Bei der Vervollständigung mit der TAB-TASTE wird die Projektdatei beachtet.

PowerShell

Um Tab-Vervollständigung zu PowerShell für die .NET CLI hinzuzufügen, erstellen oder bearbeiten Sie das in der Variablen $PROFILE gespeicherte Profil. Weitere Informationen finden Sie unter Erstellen Ihres Profils und Profile und Ausführungsrichtlinie.

Fügen Sie Ihrem Profil den folgenden Code hinzu:

# PowerShell parameter completion shim for the dotnet CLI
Register-ArgumentCompleter -Native -CommandName dotnet -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)
        dotnet complete --position $cursorPosition "$commandAst" | ForEach-Object {
            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
        }
}

Bash

Wenn Sie die Vervollständigung mit der TAB-TASTE für die .NET-CLI zur Bash-Shell hinzufügen möchten, fügen Sie der Datei .bashrc den folgenden Code hinzu:

# bash parameter completion for the dotnet CLI

function _dotnet_bash_complete()
{
  local cur="${COMP_WORDS[COMP_CWORD]}" IFS=$'\n' # On Windows you may need to use use IFS=$'\r\n'
  local candidates

  read -d '' -ra candidates < <(dotnet complete --position "${COMP_POINT}" "${COMP_LINE}" 2>/dev/null)

  read -d '' -ra COMPREPLY < <(compgen -W "${candidates[*]:-}" -- "$cur")
}

complete -f -F _dotnet_bash_complete dotnet

zsh

Wenn Sie die Vervollständigung mit der TAB-TASTE für die .NET-CLI zur zsh-Shell hinzufügen möchten, fügen Sie der Datei .zshrc den folgenden Code hinzu:

# zsh parameter completion for the dotnet CLI

_dotnet_zsh_complete()
{
  local completions=("$(dotnet complete "$words")")

  # If the completion list is empty, just continue with filename selection
  if [ -z "$completions" ]
  then
    _arguments '*::arguments: _normal'
    return
  fi

  # This is not a variable assignment, don't remove spaces!
  _values = "${(ps:\n:)completions}"
}

compdef _dotnet_zsh_complete dotnet

Fisch

Wenn Sie die Vervollständigung mit der TAB-TASTE für die .NET-CLI der fish-Shell hinzufügen möchten, fügen Sie der Datei config.fish den folgenden Code hinzu:

complete -f -c dotnet -a "(dotnet complete (commandline -cp))"

nushell

Um die Vervollständigung mit der TAB-TASTE zu Ihrer nushell für .NET CLI hinzuzufügen, fügen Sie Folgendes am Anfang Ihrer config.nu-Datei hinzu:

let external_completer = { |spans|
    {
        dotnet: { ||
            dotnet complete (
                $spans | skip 1 | str join " "
            ) | lines
        }
    } | get $spans.0 | each { || do $in }
}

Suchen Sie dann im config-Datensatz den Abschnitt completions, und fügen Sie den zuvor definierten external_completer in external hinzu:

let-env config = {
    # your options here
    completions: {
        # your options here
        external: {
            # your options here
            completer: $external_completer # add it here
        }
    }
}