Como habilitar o preenchimento com a tecla tab para a CLI do .NET

Este artigo se aplica a: ✔️ SDK do .NET 6 e versões posteriores

Este artigo descreve como configurar o completamento de tabulação entre cinco shells: PowerShell (pwsh), Bash, zsh, fish e nushell. Para outros shells, consulte as respectivas documentações dos shells para saber como configurar o preenchimento com TAB.

Scripts de conclusão de shell nativo (.NET 10+)

A partir do .NET 10, a CLI do .NET inclui scripts de conclusão de shell nativos que são executados muito mais rapidamente do que as conclusões dinâmicas disponíveis em versões anteriores. As conclusões nativas geram scripts específicos do shell que lidam com as partes estáticas da gramática da CLI diretamente no shell, proporcionando uma melhoria significativa no desempenho.

Gerar scripts de conclusão

Use o dotnet completions script comando para gerar um script de conclusão para o shell:

dotnet completions script [SHELL]

O [SHELL] parâmetro aceita um dos seguintes valores:

• bash
• fish
• nushell
• pwsh
• zsh

Se você não especificar um shell, o comando inferirá o shell correto do seu ambiente. No Windows, ele usa como padrão o PowerShell (pwsh). Em outros sistemas, ele verifica se o nome do arquivo da variável de SHELL ambiente corresponde a qualquer um dos valores de shell com suporte.

Capacidades de conclusão

Os autocompletamentos nativos fornecem diferentes níveis de suporte dependendo do shell:

Shell	Tipo de conclusão	Descrições em conclusões de guia
bash	híbrido	Não
peixe	dynamic	Não
nushell	dynamic	Não
PowerShell	híbrido	Yes
zsh	híbrido	Yes

Tipos de conclusão:

• Híbrido: gera um código específico do shell que manipula partes estáticas da gramática da CLI rapidamente, mas retorna ao dotnet complete comando para conteúdo dinâmico (como IDs de pacote NuGet).
• Dinâmico: todos os complectamentos usam o comando dotnet complete, que pode ser mais lento, mas garante cobertura abrangente.

Configurar shells para usar complementos nativos

Adicione o comando apropriado ao perfil do shell para habilitar conclusões nativas:

PowerShell

Adicione a seguinte linha ao seu perfil do PowerShell ($PROFILE):

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

Bash

Adicione a seguinte linha ao arquivo .bashrc :

eval "$(dotnet completions script bash)"

Zsh

Adicione a seguinte linha ao arquivo .zshrc :

eval "$(dotnet completions script zsh)"

Fish

Adicione a seguinte linha ao arquivo config.fish :

dotnet completions script fish | source

Nushell

Adicione o seguinte ao início do config.nu arquivo:

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

Scripts de preenchimento dinâmico (todas as versões)

Para versões do .NET anteriores ao .NET 10 ou se você preferir usar conclusões dinâmicas, poderá configurar o shell para usar o dotnet complete comando. As conclusões dinâmicas funcionam enviando a linha de comando atual para o dotnet complete comando e processando os resultados no shell.

Após configurado, o preenchimento com TAB para a CLI do .NET CLI é disparado com a inserção de um comando dotnet no shell e o pressionamento da tecla Tab. A linha de comando atual é enviada para o dotnet complete comando e os resultados são processados pelo shell. Teste os resultados sem habilitar o preenchimento com TAB enviando algo diretamente para o comando dotnet complete. Por exemplo:

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

Se esse comando não funcionar, verifique se o SDK do .NET Core 2.0 ou posterior está instalado. Se ele está instalado, mas esse comando ainda não funciona, verifique se o comando dotnet é resolvido para uma versão do SDK do .NET Core 2.0 e posterior. Use o comando dotnet --version para ver para qual versão do dotnet o caminho atual está sendo resolvido. Para obter mais informações, consulte Selecionar a versão do .NET a ser usada.

Exemplos

Estes são alguns exemplos do que o preenchimento com TAB fornece:

Entrada	Torna-se	Porque
dotnet a⇥	dotnet add	add é o primeiro subcomando, em ordem alfabética.
dotnet add p⇥	dotnet add --help	O preenchimento com TAB correlaciona as subcadeias de caracteres, e --help vem em primeiro lugar em ordem alfabética.
dotnet add p⇥⇥	dotnet add package	Pressionar a tecla Tab uma segunda vez apresenta a próxima sugestão.
dotnet package add Microsoft⇥	dotnet package add Microsoft.ApplicationInsights.Web	Os resultados são retornados em ordem alfabética.
dotnet reference remove ⇥	dotnet reference remove ..\..\src\OmniSharp.DotNet\OmniSharp.DotNet.csproj	O preenchimento com TAB reconhece o arquivo de projeto.

PowerShell

Para adicionar o preenchimento com TAB ao PowerShell na CLI do .NET, crie ou edite o perfil armazenado na variável $PROFILE. Para obter mais informações, confira Como criar seu perfil e Perfis e política de execução.

Adicione o seguinte código ao seu perfil:

# 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

Para adicionar o preenchimento com TAB ao shell do bash na CLI do .NET, adicione o seguinte código ao arquivo .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

Para adicionar o preenchimento com TAB ao shell do zsh na CLI do .NET, adicione o seguinte código ao arquivo .zshrc:

# 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

peixe

Para adicionar o preenchimento com TAB ao shell do fish na CLI do .NET, adicione o seguinte código ao arquivo config.fish:

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

nushell

Para adicionar o preenchimento da guia ao nushell para a CLI do .NET, adicione o seguinte ao início do arquivo config.nu:

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

Em seguida, no registro config, localize a seção completions e adicione o external_completer que foi definido anteriormente a external:

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