dotnet run

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

NOMBRE

dotnet run: ejecuta el código fuente sin comandos explícitos de compilación o inicio.

Sinopsis

dotnet run [<applicationArguments>]
  [-a|--arch <ARCHITECTURE>] [--artifacts-path <ARTIFACTS_DIR>]
  [-c|--configuration <CONFIGURATION>] [-e|--environment <KEY=VALUE>]
  [--file <FILE_PATH>] [-f|--framework <FRAMEWORK>] [--force] [--interactive]
  [--launch-profile <NAME>] [--no-build] [--no-dependencies]
  [--no-launch-profile] [--no-restore] [--os <OS>] [--project <PATH>]
  [-r|--runtime <RUNTIME_IDENTIFIER>] [--tl:[auto|on|off]]
  [-v|--verbosity <LEVEL>] [[--] [application arguments]]

dotnet run -h|--help

Descripción

El comando dotnet run proporciona una opción conveniente para ejecutar la aplicación desde el código fuente con un comando. Es útil para un desarrollo iterativo rápido desde la línea de comandos. El comando depende del comando dotnet build para compilar el código. Los requisitos de la compilación también se aplican a dotnet run .

Nota:

dotnet run no respeta argumentos como /property:property=value, que sí los respeta dotnet build.

Los archivos de salida se escriben en la ubicación predeterminada, que es bin/<configuration>/<target>. Por ejemplo, si tiene una aplicación netcoreapp2.1 y ejecuta dotnet run, la salida se colocará en bin/Debug/netcoreapp2.1. Los archivos se sobrescriben según sea necesario. Los archivos temporales se colocan en el directorio obj.

Si el proyecto especifica varios marcos, al ejecutar dotnet run se produce un error a menos que se use la opción -f|--framework <FRAMEWORK> para especificar el marco.

El comando dotnet run debe usarse en el contexto de proyectos, no de ensamblados compilados. Si, por el contrario, está intentando ejecutar una DLL de aplicación dependiente del marco de trabajo, debe usar dotnet sin un comando. Por ejemplo, para ejecutar myapp.dll, use:

dotnet myapp.dll

Para más información sobre el controlador, consulte Introducción a la dotnetCLI de .NET.

Para ejecutar la aplicación, el comando dotnet run resuelve las dependencias de la aplicación que se encuentran fuera del entorno de tiempo de ejecución compartido desde la caché de NuGet. Dado que se usan dependencias almacenadas en caché, no se recomienda utilizar dotnet run para ejecutar aplicaciones en producción. En su lugar, cree una implementación mediante el comando dotnet publish e implemente la salida publicada.

Restauración implícita

No es necesario ejecutar dotnet restore porque lo ejecutan implícitamente todos los comandos que necesitan que se produzca una restauración, como dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish y dotnet pack. Para deshabilitar la restauración implícita, use la opción --no-restore.

El comando dotnet restore sigue siendo válido en algunos escenarios donde tiene sentido realizar una restauración explícita, como las compilaciones de integración continua en Azure DevOps Services o en los sistemas de compilación que necesitan controlar explícitamente cuándo se produce la restauración.

Para obtener información sobre cómo administrar fuentes de NuGet, vea la documentación de dotnet restore.

Este comando admite las opciones de dotnet restore cuando se pasan con el formato largo (por ejemplo, --source). No se admiten las opciones de formato corto, como -s.

Descargas de manifiestos de cargas de trabajo

Cuando se ejecuta, este comando inicia una descarga asincrónica en segundo plano de manifiestos de publicidad de cargas de trabajo. Si la descarga no ha terminado cuando finaliza el comando, se detiene. Para obtener más información, vea Manifiestos de publicidad.

Arguments

<applicationArguments>

Argumentos pasados a la aplicación que se está ejecutando.

Los argumentos que no se reconocen por dotnet run se pasan a la aplicación. Para separar los argumentos de dotnet run los argumentos de la aplicación, use la -- opción .

Opciones

--

Delimita los argumentos a dotnet run a partir de argumentos de la aplicación que se va a ejecutar. Todos los argumentos después de este delimitador se pasan a la aplicación que se ejecuta.
-a|--arch <ARCHITECTURE>

Especifica la arquitectura de destino. Se trata de una sintaxis abreviada para establecer el identificador del entorno de ejecución (RID), donde el valor proporcionado se combina con el RID predeterminado. Por ejemplo, en un equipo win-x64, al especificar --arch x86 se establece el RID en win-x86. Si usa esta opción, no use la opción -r|--runtime. Disponible a partir de .NET 6 (versión preliminar 7).
--artifacts-path <ARTIFACTS_DIR>

Todos los archivos de salida de compilación del comando ejecutado se incluirán en subcarpetas en la ruta de acceso especificada, separadas por el proyecto. Para obtener más información, vea diseño de salida de artefactos . Disponible a partir del SDK de .NET 8.
-c|--configuration <CONFIGURATION>

Define la configuración de compilación. El valor predeterminado para la mayoría de los proyectos es Debug, pero puede invalidar los valores de configuración de compilación en el proyecto.
--disable-build-servers

Obliga al comando a omitir los servidores de compilación persistentes. Esta opción proporciona una manera coherente de deshabilitar todo el uso del almacenamiento en caché de compilación, lo que fuerza una compilación desde cero. Una compilación que no se basa en memorias caché es útil cuando las memorias caché están dañadas o tienen un estado incorrecto por algún motivo. Disponible a partir del SDK de .NET 7.
-e|--environment <KEY=VALUE>

Establece la variable de entorno especificada en el proceso que ejecutará el comando . La variable de entorno especificada no se aplica al dotnet run proceso.

Las variables de entorno que se pasan a través de esta opción tienen prioridad sobre las variables de entorno ambiente, las directivas System.CommandLine env y environmentVariables el perfil de inicio elegido. Para más información, consulte Variables de entorno.

(Esta opción se agregó en el SDK de .NET 9.0.200).
-f|--framework <FRAMEWORK>

Compila y ejecuta la aplicación con el marco especificado. El marco debe especificarse en el archivo de proyecto.
--file <FILE_PATH>

Ruta de acceso a la aplicación basada en archivos que se va a ejecutar. Si no se especifica una ruta de acceso, se usa el directorio actual para buscar y ejecutar el archivo. Para obtener más información sobre las aplicaciones basadas en archivos, consulte Compilación de aplicaciones de C# basadas en archivos.

En Unix, puede ejecutar aplicaciones basadas en archivos directamente mediante el nombre de archivo de origen en la línea de comandos en lugar de dotnet run. En primer lugar, asegúrese de que el archivo tiene permisos de ejecución. A continuación, agregue una línea #! shebang como primera línea del archivo, por ejemplo:
```
#!/usr/bin/env dotnet run
```
A continuación, puede ejecutar el archivo directamente desde la línea de comandos:
```
./ConsoleApp.cs
```
Se introdujo en el SDK de .NET 10.0.100.
--force

Fuerza la resolución de todas las dependencias, incluso si la última restauración se realizó correctamente. Especificar esta marca es lo mismo que eliminar el archivo project.assets.json.
--interactive

Permite que el comando se detenga y espere una entrada o una acción del usuario. Por ejemplo, para completar la autenticación.
--launch-profile <NAME>

El nombre del perfil de inicio (si lo hay) que se usará al iniciar la aplicación. Los perfiles de inicio se definen en el archivo launchSettings.json y se suelen denominar Development, Staging y Production. Para obtener más información, consulte Working with multiple environments (Trabajo con varios entornos).
--no-build

No compila el proyecto antes de ejecutarlo. También establece la marca --no-restore de forma implícita.
--no-cache

Omita las comprobaciones actualizadas y compile siempre el programa antes de ejecutarse.
--no-dependencies

Al restaurar un proyecto con referencias de proyecto a proyecto (P2P), se restaura el proyecto raíz y no las referencias.
--no-launch-profile

No intenta usar launchSettings.json para configurar la aplicación.
--no-restore

No ejecuta una restauración implícita al ejecutar el comando.
--no-self-contained

Publique la aplicación como una aplicación dependiente del marco. Se debe instalar un entorno de ejecución de .NET compatible en la máquina de destino para ejecutar la aplicación.
--os <OS>

Especifica el sistema operativo (SO) de destino. Se trata de una sintaxis abreviada para establecer el identificador del entorno de ejecución (RID), donde el valor proporcionado se combina con el RID predeterminado. Por ejemplo, en un equipo win-x64, al especificar --os linux se establece el RID en linux-x64. Si usa esta opción, no use la opción -r|--runtime. Disponible a partir de .NET 6.
--project <PATH>

Especifica la ruta de acceso del archivo del proyecto que se va a ejecutar (nombre de la carpeta o ruta de acceso completa). Si no se especifica, se toma como predeterminado el directorio actual.

La abreviación -p para --project está en desuso a partir del SDK de .NET 6. Durante un tiempo limitado, -p todavía se puede usar para --project a pesar de la advertencia de desuso. Si el argumento proporcionado para la opción no contiene =, el comando acepta -p como forma abreviada para --project. De lo contrario, el comando da por supuesto que -p es una forma abreviada para --property. Este uso flexible de -p para --project se eliminará gradualmente en .NET 7.
--property:<NAME>=<VALUE>

Establece una o varias propiedades MSBuild. Especifique varias propiedades delimitadas por punto y coma o repitiendo la opción:
```
--property:<NAME1>=<VALUE1>;<NAME2>=<VALUE2>
--property:<NAME1>=<VALUE1> --property:<NAME2>=<VALUE2>
```
La forma abreviada -p se puede usar para --property. Si el argumento proporcionado para la opción contiene =, -p se acepta como forma abreviada para --property. De lo contrario, el comando da por supuesto que -p es una forma abreviada para --project.

Para pasar --property a la aplicación en lugar de establecer una propiedad MSBuild, proporcione la opción después del separador de sintaxis --, por ejemplo:
```
dotnet run -- --property name=value
```
-r|--runtime <RUNTIME_IDENTIFIER>

Especifica el tiempo de ejecución de destino para el que restaurar los paquetes. Para obtener una lista de identificadores de tiempo de ejecución (RID), consulte el catálogo de RID.
--sc|--self-contained

Publique el entorno de ejecución de .NET con la aplicación para que el entorno de ejecución no tenga que instalarse en la máquina de destino.
--tl:[auto|on|off]

Especifica si el registrador de terminal debe usarse para la salida de compilación. El valor predeterminado es auto, que primero comprueba el entorno antes de habilitar el registro de terminal. La comprobación del entorno comprueba que el terminal sea capaz de usar características de salida modernas y no usa una salida estándar redirigida antes de habilitar el nuevo registrador. La opción on omite la comprobación del entorno y habilita el registro de terminal. La opción off omite la comprobación del entorno y usa el registrador de consola predeterminado.

Registrador de terminal muestra la fase de restauración seguida de la fase de compilación. Durante cada fase, los proyectos en compilación actuales aparecen en la parte inferior del terminal. Cada proyecto que se compila genera una salida del destino de MSBuild que se está compilando actualmente y la cantidad de tiempo invertido en ese destino. Puede buscar en esta información para obtener más información sobre la compilación. Cuando un proyecto termina de compilarse, se escribe una única sección "compilación completada" en la que se captura lo siguiente:
- El nombre del proyecto compilado.
- La plataforma de destino (si es de destino múltiple).
- El estado de esa compilación.
- La salida principal de esa compilación (con hipervínculo).
- Los diagnósticos generados para ese proyecto.
Esta opción está disponible a partir de .NET 8.
-v|--verbosity <LEVEL>

Establece el nivel de detalle del comando. Los valores permitidos son q[uiet], m[inimal], n[ormal], d[etailed] y diag[nostic]. De manera predeterminada, es minimal. Para obtener más información, vea LoggerVerbosity.
-?|-h|--help

Imprime una descripción de cómo usar el comando.

Variables de entorno

Hay cuatro mecanismos por los que se pueden aplicar variables de entorno a la aplicación iniciada:

Variables de entorno ambiente desde el sistema operativo cuando se ejecuta el comando.
Directivas System.CommandLine env , como [env:key=value]. Se aplican a todo dotnet run el proceso, no solo al proyecto que ejecuta dotnet run.
environmentVariables en el perfil de inicio elegido (-lp) en el archivolaunchSettings.json del proyecto, si existe. Se aplican al proyecto que ejecuta dotnet run.
-e|--environment Valores de opción de la CLI (agregados en la versión 9.0.200 del SDK de .NET). Se aplican al proyecto que ejecuta dotnet run.

El entorno se construye en el mismo orden que esta lista, por lo que la -e|--environment opción tiene la prioridad más alta.

Ejemplos

Ejecución del proyecto en el directorio actual:
```
dotnet run
```
Ejecute la aplicación basada en archivos especificada en el directorio actual:
```
dotnet run --file ConsoleApp.cs
```
La compatibilidad con aplicaciones basadas en archivos se agregó en el SDK de .NET 10.0.100.

Ejecución del proyecto especificado:

dotnet run --project ./projects/proj1/proj1.csproj

Ejecute el proyecto en el directorio actual, especificando la configuración de versión:
```
dotnet run --property:Configuration=Release
```
Ejecute el proyecto en el directorio actual (el argumento --help en este ejemplo se pasa a la aplicación, dado que se usa la opción -- en blanco):
```
dotnet run --configuration Release -- --help
```
Restaure las dependencias y herramientas del proyecto en el directorio actual para mostrar solo la salida mínima y, después, ejecute el proyecto:
```
dotnet run --verbosity m
```
Ejecute el proyecto en el directorio actual mediante el marco especificado y pase argumentos a la aplicación:
```
dotnet run -f net6.0 -- arg1 arg2
```
En el ejemplo siguiente, se pasan tres argumentos a la aplicación. Se pasa un argumento mediante -y dos argumentos se pasan después --de :
```
dotnet run -f net6.0 -arg1 -- arg2 arg3
```

Comentarios

¿Le resultó útil esta página?

Last updated on 2025-10-08