asp.net core - open - dotnet run O dotnet watch con entorno de desarrollo desde la línea de comandos?

how to open.net cli

Question

Estoy usando el comando dotnet watch para ejecutar el proyecto asp.net core. Sin embargo, de forma predeterminada, está recogiendo la Production como un entorno.

He probado ambas opciones usando:

1) > dotnet watch ASPNETCORE_ENVIRONMENT=Development

2) > dotnet run ASPNETCORE_ENVIRONMENT=Development

Pero aún retoma la producción como medio ambiente.

Nota: en Visual Studio, la variable de entorno se establece en las propiedades del proyecto como Desarrollo de forma predeterminada y se ejecuta desde Visual Studio selecciona esa variable.

La pregunta es: ¿Cómo ejecutar el proyecto central de dotnet en desarrollo desde la línea de comandos usando cualquiera ?:

1) dotnet run
2) dotnet watch

Answer 1

Consultar documentación

https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-run?tabs=netcore21

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments?view=aspnetcore-2.1

dotnet run --launch-profile EnvironmentsSample

launchSettings.json

{ 
  "profiles": {    
    "EnvironmentsSample": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Staging"
      },
      "applicationUrl": "http://localhost:54340/"
    },   
  }
}

Answer 2

Fuente: https://blogs.msdn.microsoft.com/webdev/2017/02/14/building-single-page-applications-on-asp-net-core-with-javascriptservices/

Estilo agregado.

Si está utilizando PowerShell en Windows, ejecute $Env:ASPNETCORE_ENVIRONMENT = "Development"

Si está utilizando cmd.exe en Windows, ejecute setx ASPNETCORE_ENVIRONMENT "Development" y luego reinicie el símbolo del sistema para que el cambio surta efecto

Si está utilizando Mac / Linux , ejecute export ASPNETCORE_ENVIRONMENT=Development

Answer 3

Gracias a la respuesta de @Technetium, aquí hay una actualización de dotnetcore 2.0 que me funciona muy bien:

public class Program
    {
        private static readonly Dictionary<string, string> defaults = new Dictionary<string, string> {{ WebHostDefaults.EnvironmentKey, "Development" }                                                                      };
        private static IConfiguration config;
        public static void Main(string[] args)
        {
            config = new ConfigurationBuilder()
                .AddInMemoryCollection(defaults)
                .AddEnvironmentVariables("ASPNETCORE_")
                .AddCommandLine(args)
                .Build();
            BuildWebHost(args).Run();
        }
public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseConfiguration(config)
                /* Following setting already accounted for in CreateDefaultBuilder() : https://docs.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.webhost.createdefaultbuilder?view=aspnetcore-2.0 */
                // .UseContentRoot(Directory.GetCurrentDirectory())
                .UseStartup<Startup>()
                .Build();
    }

Gracias de nuevo, @Technetium

Answer 4

No tiene que usar variables de entorno si ajusta cómo WebHostBuilder procesa su configuración. Esto es simplemente el valor predeterminado para dotnet new -t web . Por ejemplo, si desea poder establecer el entorno predeterminado en "desarrollo" en lugar de producción y facilitar la anulación del entorno en la línea de comando, puede hacerlo modificando el código Program.cs normal a partir de esto ...

    public static void Main(string[] args) {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseUrls("http://0.0.0.0:5000")
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .Build();

        host.Run();
    }

... en algo como esto ...

    private static readonly Dictionary<string, string> defaults =
        new Dictionary<string, string> {
            { WebHostDefaults.EnvironmentKey, "development" }
        };

    public static void Main(string[] args) {
        var configuration =
            new ConfigurationBuilder()
                .AddInMemoryCollection(defaults)
                .AddEnvironmentVariables("ASPNETCORE_")
                .AddCommandLine(args)
                .Build();

        var host =
            new WebHostBuilder()
                .UseConfiguration(configuration)
                .UseKestrel()
                .UseUrls("http://0.0.0.0:5000")
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseIISIntegration()
                .UseStartup<Startup>()
                .Build();

        host.Run();
    }

Al hacer esto, las variables de entorno seguirían funcionando, pero puede anularlo en la línea de comando sin dependencias de terceros, de esta manera:

dotnet run environment=development
dotnet run environment=staging

Esto es realmente lo que hacen los generadores yeoman .

Answer 5

También puede establecer la variable en línea cuando llame a dotnet :

ASPNETCORE_ENVIRONMENT=Development dotnet run

He encontrado que esto es excelente para los scripts de NPM, pero siempre se debe llamar justo antes de dotnet , por ejemplo:

{
  ...
  "scripts": {
    "start": "cd MyApp && ASPNETCORE_ENVIRONMENT=Development dotnet run",
    "watch": "cd MyApp && ASPNETCORE_ENVIRONMENT=Development dotnet watch"
  },
}

Nota: Esto solo funciona en OS X o Linux; para una solución multiplataforma, puede usar cross-env :

npm install cross-env -D

Luego cambie los scripts a:

{
  ...
  "scripts": {
    "start": "cd MyApp && cross-env ASPNETCORE_ENVIRONMENT=Development dotnet run",
    "watch": "cd MyApp && cross-env ASPNETCORE_ENVIRONMENT=Development dotnet watch"
  },
}

Answer 6

ASPNETCORE_ENVIRONMENT es una variable de entorno (y AFAIK) no un cambio al dotnet cli.

Entonces, lo que haría es configurarlo antes de usar la herramienta:

rem Windows
C:/> set ASPNETCORE_ENVIRONMENT=Development
C:/> dotnet ...

rem Unix
$ export ASPNETCORE_ENVIRONMENT=Development
$ dotnet ...