Come abilitare il completamento automatico per l'interfaccia a riga di comando di .NET

Questo articolo si applica a: ✔️ .NET 6 SDK e versioni successive

Questo articolo descrive come configurare il completamento della scheda per cinque shell: PowerShell (pwsh), Bash, zsh, fish e nushell. Per altre shell, consultare la relativa documentazione per configurare il completamento dei comandi.

Script nativi di completamento della shell (.NET 10+)

A partire da .NET 10, l'interfaccia della riga di comando di .NET include script di completamento della shell nativi che vengono eseguiti molto più velocemente rispetto ai completamenti dinamici disponibili nelle versioni precedenti. I completamenti nativi generano script specifici della shell che gestiscono le parti statiche della grammatica dell'interfaccia della riga di comando direttamente nella shell, offrendo un miglioramento significativo delle prestazioni.

Generare script di completamento

Usa il comando dotnet completions script per generare uno script di completamento per la shell.

dotnet completions script [SHELL]

Il [SHELL] parametro accetta uno dei valori seguenti:

• bash
• fish
• nushell
• pwsh
• zsh

Se non si specifica una shell, il comando deduce la shell corretta dall'ambiente in uso. In Windows per impostazione predefinita è PowerShell (pwsh). In altri sistemi verifica se il nome file della variabile di SHELL ambiente corrisponde a uno dei valori della shell supportati.

Capacità di completamento

I completamenti nativi offrono diversi livelli di supporto a seconda della shell:

Guscio	Tipo di completamento	Descrizioni nei completamenti delle schede
bash	ibrido	NO
pesce	dynamic	NO
nushell	dynamic	NO
PowerShell	ibrido	Yes
zsh	ibrido	Yes

Tipi di completamento:

• Ibrido: genera codice specifico della shell che gestisce rapidamente le parti statiche della grammatica della CLI, ma esegue un fallback al comando per il dotnet complete contenuto dinamico, ad esempio gli ID dei pacchetti NuGet.
• Dinamico: tutti i completamenti passano attraverso il dotnet complete comando, che potrebbe essere più lento, ma garantisce una copertura completa.

Configurare le shell per l'uso dei completamenti nativi

Aggiungere il comando appropriato al profilo della shell per abilitare i completamenti nativi:

PowerShell

Aggiungere la riga seguente al profilo di PowerShell ($PROFILE):

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

Bash

Aggiungere la riga seguente al .bashrc file:

eval "$(dotnet completions script bash)"

Zsh

Aggiungere la riga seguente al .zshrc file:

eval "$(dotnet completions script zsh)"

Fish

Aggiungere la riga seguente al config.fish file:

dotnet completions script fish | source

NuShell

Aggiungere quanto segue all'inizio del config.nu file:

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

Script di completamento dinamico (tutte le versioni)

Per le versioni di .NET precedenti a .NET 10 o se si preferisce usare completamenti dinamici, è possibile configurare la shell per l'uso del dotnet complete comando . I completamenti dinamici funzionano inviando la riga di comando corrente al dotnet complete comando ed elaborando i risultati nella shell.

Dopo la configurazione, il completamento automatico con tab per l'interfaccia della riga di comando di .NET viene attivato immettendo un dotnet comando nella shell e quindi premendo il tasto Tab. La riga di comando corrente viene inviata al dotnet complete comando e i risultati vengono elaborati dalla shell. È possibile testare i risultati senza abilitare il completamento tabulazione inviando qualcosa direttamente al comando dotnet complete. Per esempio:

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

Se il comando non funziona, assicurarsi che sia installato .NET Core 2.0 SDK o versione successiva. Se è installato ma il comando non funziona ancora, assicurarsi che il dotnet comando venga risolto in una versione di .NET Core 2.0 SDK o versione successiva. Utilizzare il comando dotnet --version per visualizzare quale versione del percorso corrente dotnet è utilizzata. Per altre informazioni, vedere Selezionare la versione di .NET da usare.

Examples

Ecco alcuni esempi di ciò che fornisce il completamento automatico dei tab:

Input	Becomes	Because
dotnet a⇥	dotnet add	add è il primo sottocomando, alfabeticamente.
dotnet add p⇥	dotnet add --help	Il completamento tramite tab corrisponde alle sottostringhe e --help viene prima in ordine alfabetico.
dotnet add p⇥⇥	dotnet add package	Premendo il tasto Tab una seconda volta si visualizza il suggerimento successivo.
dotnet package add Microsoft⇥	dotnet package add Microsoft.ApplicationInsights.Web	I risultati vengono restituiti alfabeticamente.
dotnet reference remove ⇥	dotnet reference remove ..\..\src\OmniSharp.DotNet\OmniSharp.DotNet.csproj	Il completamento tramite tabulazione tiene conto dei file di progetto.

PowerShell

Per aggiungere il completamento tramite tabulazione a PowerShell per la .NET CLI, creare o modificare il profilo archiviato nella variabile $PROFILE. Per altre informazioni, vedere How to create your profile (Come creare un profilo) e Profiles and execution policy (Profili e criteri di esecuzione).

Aggiungere il codice seguente al profilo:

# 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

Per aggiungere il completamento tramite tab alla shell Bash per la .NET CLI, aggiungere il codice seguente nel file .bashrc.

# 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

Per aggiungere il completamento della scheda alla shell zsh per l'interfaccia della riga di comando di .NET, aggiungere il codice seguente al .zshrc file:

# 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

pesce

Per aggiungere il completamento tramite tabulazione alla shell fish per la CLI .NET, aggiungere il codice seguente al file config.fish.

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

nushell

Per aggiungere il completamento con tab all'interfaccia nushell per la riga di comando di .NET, aggiungere quanto segue all'inizio del file config.nu:

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

Quindi nel record config, trovare la sezione completions e aggiungere il external_completer definito in precedenza a external.

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