Procedimiento para habilitar la finalización con tabulación para la CLI de .NET

Este artículo se aplica a: ✔️ SDK de .NET 6 y versiones posteriores

En este artículo se describe cómo configurar la finalización de tabulaciones para cinco shells: PowerShell (pwsh), Bash, zsh, fish y nushell. Para otros shells, consulte su documentación sobre cómo configurar la finalización de pestañas.

Scripts de autocompletado nativos para shell (.NET 10+)

A partir de .NET 10, la CLI de .NET incluye scripts de finalización de shell nativos que se ejecutan mucho más rápido que las finalizaciones dinámicas disponibles en versiones anteriores. Las finalizaciones nativas generan scripts específicos del shell que controlan las partes estáticas de la gramática de la CLI directamente en el shell, lo que proporciona una mejora significativa del rendimiento.

Generar scripts de finalización

Use el dotnet completions script comando para generar un script de finalización para el shell:

dotnet completions script [SHELL]

El [SHELL] parámetro acepta uno de los siguientes valores:

• bash
• fish
• nushell
• pwsh
• zsh

Si no especifica un shell, el comando deduce el shell correcto de su entorno. En Windows, el valor predeterminado es PowerShell (pwsh). En otros sistemas, comprueba si el nombre de archivo de la SHELL variable de entorno coincide con cualquiera de los valores de shell admitidos.

Capacidades de finalización

Las finalizaciones nativas proporcionan diferentes niveles de soporte dependiendo del shell.

Shell	Tipo de finalización	Descripciones en finalizaciones de pestañas
Bash	híbrido	No
fish	dynamic	No
nushell	dynamic	No
PowerShell	híbrido	Sí
zsh	híbrido	Sí

Tipos de finalización:

• Híbrido: Genera código específico del shell que maneja rápidamente las partes estáticas de la gramática de la CLI, pero recurre al comando dotnet complete para manejar contenido dinámico, como los identificadores de paquetes de NuGet.
• Dinámico: todas las finalizaciones pasan por el dotnet complete comando, lo que puede ser más lento, pero garantiza una cobertura completa.

Configuración de shells para usar finalizaciones nativas

Agregue el comando adecuado al perfil del shell para habilitar las finalizaciones nativas:

PowerShell

Agregue la siguiente línea al perfil de PowerShell ($PROFILE):

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

Bash

Agregue la siguiente línea al .bashrc archivo:

eval "$(dotnet completions script bash)"

Zsh

Agregue la siguiente línea al .zshrc archivo:

eval "$(dotnet completions script zsh)"

Fish

Agregue la siguiente línea al config.fish archivo:

dotnet completions script fish | source

NuShell

Agregue lo siguiente al principio del config.nu archivo:

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

Scripts de finalización dinámica (todas las versiones)

En el caso de las versiones de .NET anteriores a .NET 10 o si prefiere usar finalizaciones dinámicas, puede configurar el shell para que use el dotnet complete comando . Las finalizaciones dinámicas funcionan enviando la línea de comandos actual al dotnet complete comando y procesando los resultados en el shell.

Una vez que se ha configurado, para desencadenar la finalización con tabulación para la CLI de .NET, escriba un comando dotnet en el shell y presione el tabulador. La línea de comandos actual se envía al dotnet complete comando y el shell procesa los resultados. Puede probar los resultados sin activar el autocompletado de pestañas enviando algo directamente al comando dotnet complete. Por ejemplo:

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

Si ese comando no funciona, asegúrese de que está instalado el SDK de .NET Core 2.0 o posterior. Si está instalado, pero ese comando todavía no funciona, asegúrese de que el dotnet comando se resuelve en una versión del SDK de .NET Core 2.0 o posterior. Use el comando dotnet --version para ver en qué versión de dotnet se resuelve la ruta de acceso actual. Para obtener más información, consulte Selección de la versión de .NET que se va a usar.

Ejemplos

Estos son algunos ejemplos de lo que proporciona la finalización de pestañas:

Entrada	Se convierte en	Porque
dotnet a⇥	dotnet add	add es el primer subcomando, alfabéticamente.
dotnet add p⇥	dotnet add --help	La finalización con tabulación hace coincidir las subcadenas y --help aparece primero alfabéticamente.
dotnet add p⇥⇥	dotnet add package	Al presionar la pestaña una segunda vez se abre la siguiente sugerencia.
dotnet package add Microsoft⇥	dotnet package add Microsoft.ApplicationInsights.Web	Los resultados se devuelven alfabéticamente.
dotnet reference remove ⇥	dotnet reference remove ..\..\src\OmniSharp.DotNet\OmniSharp.DotNet.csproj	La finalización con tabulación es compatible con archivos de proyecto.

PowerShell

Para agregar finalización con tabulación a PowerShell para la CLI de .NET, cree o edite el perfil almacenado en la variable $PROFILE. Para obtener más información, vea Cómo crear el perfil y Los perfiles y la directiva de ejecución.

Agregue el código siguiente al 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 agregar finalización con tabulación al shell de bash para la CLI de .NET, agregue el código siguiente al archivo .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 agregar finalización con tabulación al shell de zsh para la CLI de .NET, agregue el código siguiente al archivo .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

fish

Para agregar la finalización con tabulación al shell de fish para la CLI de .NET, agregue el código siguiente al archivo config.fish:

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

nushell

Para agregar la finalización con tabulación a nushell para la CLI de .NET, agregue el código siguiente al comienzo del archivo config.nu:

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

Y, luego, en el registro config, busque la sección completions y agregue el external_completer que se definió anteriormente a external:

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