How to use multiple appsettings.json files in .net core webapi project for different environments

Managing configuration is one of the most important parts of any .NET Core application.

ASP.NET Core provides a powerful configuration system that allows you to load multiple configuration files, override settings per environment, and keep secrets out of source control.

Why Use Multiple AppSettings Files?

Advantages

1. Cleaner separation between environments

Each environment has its own config file:

  • dev database

  • test API URLs

  • production connection strings

2. No need to modify code during deployment

Switch environment → settings automatically apply.

3. Safe and secure deployments

Production secrets never appear in development files.

4. Works cleanly with CI/CD & Docker

Different settings per environment, same codebase.

5. Supporting reloadOnChange

You can update JSON settings without restarting the app (in Development).

Disadvantages

1. Requires proper environment variable setup

If ASPNETCORE_ENVIRONMENT is not set correctly, the wrong config loads.

2. More files to maintain

Multiple environments = more configuration files.

3. Sensitive data risk

If production settings accidentally get committed to Git → security issue.
Use Secret Manager or Azure Key Vault for secrets.

4. Reload doesn’t work in Production (IIS) for in-process apps

reloadOnChange is ignored by IIS for in-process hosting.

Step by step  example

1. Created .net core webapi project.

2. Added required nuget packages for entity framework core and sql server.
    (Microsoft.EntityFrameworkCore.SqlServer, Microsoft.EntityFrameworkCore.Tools)

3. Created three database for Development, QA and Live environment in SQL server. Run dbcontext-       scaffold command to generate class from database table and context.
    or you can use migration to generate database.

4. Add two more appsettings json files in the project root folder. By default when you create project appsetting.json and appsetting.Development.json file are created.
   
    a. appsettings.QA.json
    b. appsettings.Live.json

6. Added connection string for each environment in respective appsettings json file.

7. Debugging/Development time set the environment variable in launchsettings.json file.
    "ASPNETCORE_ENVIRONMENT": "Development" / "QA" / "Live"


or 
you can set ASPNETCORE_ENVIRONMENT variable by right click on solution file and click on properties page. In Property pages click on Debug => General => Debug Launch Profile UI, following popup will open you can set your variable value 


8. In Program.cs file, added code to set the connection string. 


9. Run the project and verify the connection string is picked from the correct appsettings json file based on the environment variable value set.


10. After deployment to respective environment, set the environment variable in the hosting server environment variable. 
    or
    set environment variable in the iis server for respective application pool.
    or
    set environment variable in web.config file for respective environment.(recommended)

    We will set environment variable in web.config file. 

    Sample web.config file



11. Run the project and verify the connection string is picked from the correct appsettings json file based on the environment.

For more detail you can check youtube video : Click to watch video







Comments

Post a Comment

Popular posts from this blog

Understanding Middleware in .NET Core

Image
What is Middleware in ASP.NET Core? If you're starting to learn ASP.NET Core , you've probably heard the word "middleware" quite a few times. It might sound complicated at first, but don’t worry — in this post, we’ll break it down into simple terms . You’ll learn: What middleware is Why it's important How it works How to create your own Best practices (and things to avoid) What is Middleware in .NET Core? Middleware is a piece of code that sits between the incoming HTTP request and the outgoing HTTP response in an ASP.NET Core app. It can: Inspect or modify the request Handle authentication or logging Pass the request to the next step Or even stop the request entirely In simple words: Middleware is like a checkpoint that performs some logic on every request before it reaches your controller or API. Real-Life Analogy: The Airport Imagine you're at an airport going through various checks: Security Check (Middleware 1): Checks...
Read more

Understanding the Difference Between Controller and ControllerBase in ASP.NET Core

Image
  Understanding the Difference Between Controller and ControllerBase in ASP.NET Core   What are Controllers in ASP.NET Core? In ASP.NET Core, controllers are the classes that handle incoming HTTP requests from clients (like web browsers or apps) and decide how to respond. They are an essential part of the MVC (Model-View-Controller) architecture and Web API development. Controllers receive input, interact with the application's business logic or data, and then return a response—this could be an HTML page, JSON data, a file, or even a redirect to another page. They act as the “middleman” between users and your application's backend.   Why Controllers Matter in Web Apps and APIs Controllers play a crucial role because they determine how your application communicates with the outside world: In web applications, controllers render views (HTML pages) that users see in their browsers. They make websites interactive by handling forms, navigation, and user input. ...
Read more

Database Approaches in .NET Core: Code-First vs Database-First Explained for Beginners

Image
Why Most Beginners Get Confused Choosing a Database Approach in .NET Core?  Beginners often confused - Here are the main reasons why this confusion happens:   1. Too Many Options, Not Enough Context It's common for beginners to feel overwhelmed by the sheer number of data access options in the .NET ecosystem. The key is to understand that these technologies are not competing to solve the same problem. Instead, they operate at different levels of abstraction to address different needs, from raw speed to developer productivity.    2. .NET Learning Curve is Already Steep ASP.NET Core has a lot: Startup, Middleware, Dependency Injection, Routing, Controllers, Services. Adding database decisions (e.g., how to scaffold models or handle migrations) is just another layer on top of all that.   3. Misleading or Fragmented Tutorials Some tutorials say “Use EF Core, it's simple!” Others say “EF is slow, ...
Read more