How do you configure environment variables in an ASP.NET Core application?

In ASP.NET Core, environment variables are used to configure application settings across different environments (e.g., Development, Staging, Production). They are particularly useful for sensitive data (like connection strings, API keys) or settings that vary by deployment environment. ASP.NET Core provides a built-in way to access and use these variables in configuration.

Steps to Configure Environment Variables in ASP.NET Core

1. Set Environment-Specific Variables

   Set environment variables in your deployment environment, for example, using:

   • Environment-Specific Files (e.g., launchSettings.json in development).
   • Operating System Commands:
     • Windows: setx ASPNETCORE_ENVIRONMENT "Development"
     • Linux/macOS: export ASPNETCORE_ENVIRONMENT=Development
   • Docker Compose: environment key in docker-compose.yml.
   • Azure App Service: Configure under "Application Settings" in the Azure portal.

2. Access Environment Variables in ASP.NET Core

   ASP.NET Core automatically reads environment variables into the IConfiguration object in Startup.cs. By default, ASP.NET Core includes environment variables as part of the configuration providers.

   Example Configuration Providers in Program.cs:

   
   public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureAppConfiguration((context, config) =>
           {
               config.AddEnvironmentVariables();
           })
           .ConfigureWebHostDefaults(webBuilder =>
           {
               webBuilder.UseStartup<Startup>();
           });
   

3. Access Environment Variables in appsettings.json

   Environment variables can override settings in appsettings.json by using a naming convention where : denotes hierarchy in JSON paths.

   Example of appsettings.json:

   
   {
     "ConnectionStrings": {
       "DefaultConnection": "Server=myServer;Database=myDb;User Id=myUser;Password=myPass;"
     }
   }
   

   Set an environment variable like ConnectionStrings__DefaultConnection to override this value without modifying appsettings.json.

4. Using Environment-Specific appsettings Files

   ASP.NET Core loads appsettings.json files for each environment if they are named accordingly (e.g., appsettings.Development.json). The active environment is determined by the ASPNETCORE_ENVIRONMENT variable.

Accessing Configuration in Code

1. Inject IConfiguration in Controllers or Services:

   
   public class MyController : Controller
   {
       private readonly IConfiguration _config;
   
       public MyController(IConfiguration config)
       {
           _config = config;
       }
   
       public IActionResult Index()
       {
           var connectionString = _config["ConnectionStrings:DefaultConnection"];
           return Content($"Connection String: {connectionString}");
       }
   }
   

2. Accessing the Current Environment

   The current environment can be accessed by injecting IWebHostEnvironment and checking EnvironmentName.

   
   public class MyService
   {
       private readonly IWebHostEnvironment _env;
   
       public MyService(IWebHostEnvironment env)
       {
           _env = env;
       }
   
       public void PrintEnvironment()
       {
           Console.WriteLine($"Current Environment: {_env.EnvironmentName}");
       }
   }
   

Example Scenarios of Using Environment Variables

1. Override a Setting: Use environment variables to override a connection string or API key without changing appsettings.json.
2. Toggle Features: Set feature toggles or flags in environment variables for enabling or disabling certain features in specific environments.
3. Environment-Specific appsettings: Use ASPNETCORE_ENVIRONMENT to specify different configurations for Development, Staging, and Production.

Common Interview Questions on Environment Variables in ASP.NET Core

1. How do you set the environment in ASP.NET Core?

   • By setting the ASPNETCORE_ENVIRONMENT variable, usually in system settings, deployment configuration, or launchSettings.json.

2. What is the purpose of the IConfiguration interface in ASP.NET Core?

   • IConfiguration provides a way to access configuration settings, including environment variables, from various sources like appsettings.json, environment variables, and command-line arguments.

3. How do you override appsettings.json values with environment variables?

   • Use double underscores (__) to represent the JSON path hierarchy, e.g., ConnectionStrings__DefaultConnection for appsettings.json.

4. What is the purpose of ASPNETCORE_ENVIRONMENT?

   • It defines the environment (Development, Staging, Production) the application is running in, allowing ASP.NET Core to load environment-specific settings, files, and services.

5. Why might you use environment variables instead of storing all configurations in appsettings.json?

   • For security and flexibility, particularly with sensitive information (e.g., passwords) or values that differ by environment, such as deployment-specific settings.