How to create environments with appSettings?

Question

In previous projects i could click the Configuration or Debug menu (in the top bar) and set a new Configuration. This was displayed when i expanded web.config and i could use this to change environments to use different database connection strings etc.

Im now using .Net 6 and Visual Studio 2022. I carry out the same steps but the experience isnt as straightforward as it was when using the prior version.

In the new version it seems, i have to add code in the Startup class to perhaps list what environment i need to use which doesnt sound right for some reason. In the old version i could swap from Debug to Home to Staging to Live to get the appropriate environment.

Could someone give me some guidance on how i could do the same if using .Net 6 and customising the appSettings.json file for multiple environments and how to switch between them?

Thanks

Answer 1

You can add any environment and different app settings per environment easily. So you don't need to add any code the startup class in ASP.NET Core and everything works by default. You may want to have some code, probably when it comes to have a different feature (not a different config) for different environments (for example, exposing an endpoint just in staging environment), but for app settings, no code. Just go with the configs in proper files and choose the profile to run.

For example, if you want a different app settings for a new environment called Home, do the followings:

1. Add a appsettings.Home.json file to the project.
2. Add the setting to the file, for example:

      {
        "DetailedErrors": true,
        "Logging": {
          "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
          }
        },
        "MyAppSettings": {
          "Title": "Hello from Home environment!"
        }
      }
   

3. Add the value for the other environments as well.
4. Now to choose the profile or environment, open launchSettings.json which is under Properties folder and set the environment in ASPNETCORE_ENVIRONMENT:

      {
        "iisSettings": {
          "windowsAuthentication": false,
          "anonymousAuthentication": true,
          "iisExpress": {
            "applicationUrl": "http://localhost:5061",
            "sslPort": 0
          }
        },
        "profiles": {
          "Home": {
            "commandName": "Project",
            "dotnetRunMessages": true,
            "launchBrowser": true,
            "applicationUrl": "http://localhost:5110",
            "environmentVariables": {
              "ASPNETCORE_ENVIRONMENT": "Home"
            }
          },
          "IIS Express": {
            "commandName": "IISExpress",
            "launchBrowser": true,
            "environmentVariables": {
              "ASPNETCORE_ENVIRONMENT": "Development"
            }
          }
        }
      }
   

This basically enables the Home environment:

Now when you run the application, it will read the app settings from the environment that you specified in launchsettings.json.

You can define or add any other environment that you want, using the lunchsettings.json or using the project properties as mentioned in the other answer.

To see it in action:

@page
@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}


    @Configuration.GetSection("MyAppSettings")["Title"]

And if you run the app, with Home profile:

To learn more take a look at following resources:

• Development environment and launchsettings
• Launch profile (ASP.NET Core)

Answer 2

Create an appsetting file for each environment e.g. appsettings.Development.Json

Then in Startup

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
        .AddEnvironmentVariables();


Configuration = builder.Build();
}

Next, in debug properties, set the environment.

For going live, create an environment variable on the server if one server or if you have dedicated servers set them accordingly.

See also, the following stackoverflow post.

Here is an example I did for a contract.

Answer 3

In .NET, you can use the appSettings section of the configuration file (usually Web.config or App.config) to store configuration values. You can create separate environments by having different configuration files for each environment, and then switch between them based on the current environment. Here's how you can do this:

Create separate configuration files for each environment, such as Web.config, Web.Development.config, Web.Staging.config, and Web.Production.config.

In the main configuration file (Web.config), define the values that are common to all environments.

In each of the environment-specific configuration files (e.g., Web.Development.config), add or modify the values as needed for that environment.

Use the transform feature in Visual Studio to automatically apply the environment-specific configuration when you build your application.

Determine the current environment in your code and choose the appropriate configuration file to use. You can do this by using an environment variable, checking a command-line argument, or using a method of your own choosing.

Here's an example of what a Web.config file might look like:

php
Copy code
<configuration>
  <appSettings>
    <add key="Key1" value="Value1" />
    <add key="Key2" value="Value2" />
  </appSettings>
</configuration>
And here's an example of what a Web.Development.config file might look like:

php
Copy code
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <appSettings>
    <add key="Key2" value="DevelopmentValue2" xdt:Transform="SetAttributes" xdt:Locator="Match(key)" />
  </appSettings>
</configuration>
The transform feature will automatically apply the values from the environment-specific configuration file when you build the application, so that the appSettings section in the final configuration file will contain the values specific to the environment you are building for.