如何使用通用主机 (HostBuilder) 为 .NET Core 控制台应用程序设置托管环境名称

Question

I am setting up a .NET Core 2.x console app as a Windows service and need to load an appsettings json file based on the environment. I was thinking to start the service with a command line argument that identifies the environment. How can I do that in Visual Studio? No matter what I set in the project settings, the EnvironmentName value is always "Production".

How can I set my environment from a command line argument?

var hostBuilder = new HostBuilder()
                 .UseContentRoot(Directory.GetCurrentDirectory())
                 .ConfigureAppConfiguration((hostingContext, config) =>
                 {
                     var env = hostingContext.HostingEnvironment;
                     config.AddCommandLine(args);
                     config.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: false, reloadOnChange: true);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices((hostContext, services) =>
                 {
                     //Inject additional services as needed
                     services.AddHostedService<JobRunner>();
                });

Answer 1

You can set the environment from the command line variables via the ConfigureHostConfiguration extension method.

Set up the configuration for the builder itself. This will be used to initialize the Microsoft.Extensions.Hosting.IHostEnvironment for use later in the build process.

var hostBuilder = new HostBuilder()
    .UseContentRoot(Directory.GetCurrentDirectory())
    .ConfigureHostConfiguration(configurationBuilder => {
        configurationBuilder.AddCommandLine(args);
    })
    .ConfigureAppConfiguration((hostingContext, cfg) =>
    {
        // ...

        var env = hostingContext.HostingEnvironment;
        Console.WriteLine(env.EnvironmentName); // Test
        // ...
    });
    
    // ...

    hostBuilder.Build();

---

In Visual Studio, you configure the application arguments with the same ones as being used by dotnet run which is --environment ,
eg dotnet run --environment Test .

Without this application argument, the hosting environment defaults back to Production .

Answer 2

To pick up the hosting environment from environment variables, you can also add:

.ConfigureHostConfiguration(config =>
{
    config.AddEnvironmentVariables();
})

Then use Environment environment variable to pass the actual environment.

Answer 3

In Visual Studio , you can add an environment variable under the Debug tab of the console application properties. For a console application the environment variable provider name must be prefixed by DOTNET_ for the generic host builder to recognize it. In this case, the provider name is DOTNET_ENVIRONMENT .

If this provider name is not specified, the default is Production .

Reference: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-5.0#host-configuration

Answer 4

Another method is to use the "UseEnvironnement" method directly on the host builder:

https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.hostinghostbuilderextensions.useenvironment?view=dotnet-plat-ext-5.0

For example:

   public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseEnvironment("dev") // Magic is here
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseUrls("http://0.0.0.0:8081");
                    webBuilder.UseStartup<Startup>();
                });

Answer 5

In Visual Studio 2022 and .NET 6.0, appsettings.json and appsettings.[EnvironmentName].json are automatically included in configuration sources when using HostBuilder:

So there is no need to manually add these in ConfigureServices.

You still need to set EnvironmentName in launchSettings.json or as a commandline argument as shown in the other answers.

Answer 6

If you are using visual studio and you have project configuration (Debug, Release, CustomUser...) then you could include appsettings.[config-name].json like this:

Host
  .CreateDefaultBuilder(args)
  .ConfigureAppConfiguration((context, builder) => {
     //add visual studio configuration manager
     builder.AddJsonFile($"appSettings.{Assembly.GetExecutingAssembly().GetCustomAttribute<AssemblyConfigurationAttribute>().Configuration}.json", true);
     ...
   })
    ...

Answer 7

If you are using Visual Studio 2022 with.Net 5, the UI could be a bit overwhelming. Its simple to edit launchSettings.json file under properties.

Mine looks as follows. Note its DOTNET_ENVIRONMENT and NOT ASPNETCORE_ENVIRONMENT for .NET Core console app using Generic Host (HostBuilder)

{
  "profiles": {
    "Bvh.HrSita.DbMigrator": {
      "commandName": "Project",
      "environmentVariables": {
        "DOTNET_ENVIRONMENT": "Development"
      }
    },
    "Bvh.HrSita.DbMigrator.Prod": {
      "commandName": "Project",
      "environmentVariables": {
        "DOTNET_ENVIRONMENT": "Production"
      }
    },
    "Bvh.HrSita.DbMigrator.Stag": {
      "commandName": "Project",
      "environmentVariables": {
        "DOTNET_ENVIRONMENT": "Staging"
      }
    },
    "Docker": {
      "commandName": "Docker"
    }
  }
}

Now select what ever profile you want when you launch the project. The following shows it all along with Program.cs.

And finally if you are trying to run the same in an Azure DevOps pipeline, the task should be as shown below. The arguments should have --environment Production. Note that adding env: is somehow NOT working for me as suggested here .

    - task: DotNetCoreCLI@2
      displayName: 'Run DbMigrator Project on the newly provisoned database'
      inputs:
        command: run
        projects: '$(Pipeline.Workspace)/$(finalBuildArtifactName)/src/Bvh.HrSita.DbMigrator/Bvh.HrSita.DbMigrator.csproj'
        arguments: '--configuration $(BuildConfiguration) --environment Production'
      env: 
        DOTNET_ENVIRONMENT: Production

Answer 8

To add to pfx's accepted answer above, in Visual studio 2022 , the environment variable can be set either via Properties window in UI:

or set the environment variable:

or directly edit the launchSettings.json file under Properties and add command line arguement:

Answer 9

I run into this issue time and time again and can never remember what my solution was from the previous time I ran into it. Typically, I'm simply trying to get a Development and Production environment in my console app like you get by default with a web app (configured with launchSettings.json and other more buried mechanisms).

At the beginning of my Program.cs in my console app, I add:

#if DEBUG
    Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
#endif

var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
Console.WriteLine($"{env}");

If the debug condition is not met, it always defaults to Production as the OP mentioned.

However, you could also just as easily set more simple variables with the debug condition:

var env = "Production";
#if DEBUG
    env = "Development";
#endif
Console.WriteLine($"{env}");

It's not command line, but should work as a solution. I also rarely see this suggested and found this digging through one of my older projects (after hours of searching online), so I'm not sure if it has any downsides (other than mostly only being good for one other environment besides Production)? Please leave a comment if there are other gotchas.

Part of the reason for posting this answer is so my future self can hopefully find it more quickly than this time around.