Setup appsettings.json with Transformation in Console Application of .NET Framework (4.8) and Reading in POCO Models

Welcome to this step-by-step guide on setting up appsettings.json with transformation in a Console Application of .NET Framework (4.8) and reading the configuration in POCO (Plain Old CLR Objects) models. By the end of this article, you’ll be able to configure and read your application settings with ease.

What is appsettings.json?

appsettings.json is a JSON file used to store application settings and configurations in .NET Core and .NET Framework applications. This file allows you to separate your application’s configuration from the code, making it easier to manage and maintain.

Why Use Transformation in appsettings.json?

Transformation in appsettings.json enables you to have different sets of configuration settings for different environments, such as development, staging, and production. This feature allows you to override specific settings based on the environment, making it easier to deploy your application to different environments.

Benefits of Using Transformation in appsettings.json

• Separation of concerns: Keep your application’s configuration separate from the code.
• Environment-specific settings: Easily switch between different environments without changing the code.
• Faster deployment: Deploy your application to different environments with the correct settings.

Creating a Console Application in .NET Framework (4.8)

Let’s create a new Console Application in .NET Framework (4.8) to demonstrate the setup of appsettings.json with transformation.

1. Open Visual Studio and create a new project.
2. Select “Console App (.NET Framework)” under the “Windows” section.
3. Name your project (e.g., “AppSettingsExample”) and select “.NET Framework 4.8” as the target framework.
4. Click “OK” to create the project.

Adding appsettings.json to the Project

Next, we’ll add the appsettings.json file to our project.

1. Right-click on the project in Solution Explorer and select “Add” > “New Item…”.
2. Select “JSON File” and name it “appsettings.json”.
3. Click “Add” to add the file to your project.

Configuring appsettings.json with Transformation

In this section, we’ll configure appsettings.json with transformation. We’ll create two environments: “Development” and “Production”.

{
  "AppSettings": {
    "Environment": "Development",
    "ConnectionString": "Server=mydevserver;Database=mydb;User Id=myuser;Password=mypassword;"
  }
}

Create a new JSON file named “appsettings.Development.json” and add the following configuration:

{
  "AppSettings": {
    "ConnectionString": "Server=mydevserver;Database=mydb;User Id=myuser;Password=mypassword;"
  }
}

Create another JSON file named “appsettings.Production.json” and add the following configuration:

{
  "AppSettings": {
    "ConnectionString": "Server=myprodserv;Database=myproddb;User Id=myproduser;Password=myprodpwd;"
  }
}

We’ve now set up our appsettings.json files with transformation. In the next section, we’ll learn how to read these settings in our POCO models.

Reading appsettings.json in POCO Models

Create a new class called “AppSettings” to hold our application settings.

public class AppSettings
{
    public string ConnectionString { get; set; }
    public string Environment { get; set; }
}

In your Program.cs file, add the following code to read the appsettings.json file:

using System;
using System.IO;
using Microsoft.Extensions.Configuration;

namespace AppSettingsExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container
            builder.Services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));

            var app = builder.Build();

            var config = app.Services.GetService<IConfiguration>();
            var appSettings = config.GetSection("AppSettings").Get<AppSettings>();

            Console.WriteLine($"Environment: {appSettings.Environment}");
            Console.WriteLine($"ConnectionString: {appSettings.ConnectionString}");

            Console.ReadLine();
        }
    }
}

In the above code, we’re using the `Microsoft.Extensions.Configuration` namespace to read the appsettings.json file. We’re also using dependency injection to inject the `IConfiguration` interface, which provides access to the application’s configuration.

Running the Application

Let’s run our application to see the appsettings.json configuration in action.

Set the “AppSettingsExample” project as the startup project and press F5 to run the application.

You should see the following output:

Environment: Development
ConnectionString: Server=mydevserver;Database=mydb;User Id=myuser;Password=mypassword;

To see the production settings, change the “Environment” value in the appsettings.json file to “Production” and re-run the application.

Environment: Production
ConnectionString: Server=myprodserv;Database=myproddb;User Id=myproduser;Password=myprodpwd;

Conclusion

In this article, we’ve learned how to set up appsettings.json with transformation in a Console Application of .NET Framework (4.8) and read the configuration in POCO models. By following these steps, you can easily manage and maintain your application’s configuration across different environments.

Remember to keep your appsettings.json files separate from your code and use transformation to manage different environments. This approach will make your application more flexible and easier to deploy.

Environment	appsettings.json
Development	appsettings.Development.json
Production	appsettings.Production.json

We hope this article has been helpful in setting up appsettings.json with transformation in your .NET Framework (4.8) Console Application. Happy coding!

Frequently Asked Question

Get the scoop on setting up appsettings.json with transformation in Console Application of .NET Framework (4.8) and reading in POCO models!