DEV Community

Roel
Roel

Posted on

8

How to C#: Add Configuration to your .NET 8 Web API Application

Managing configuration settings is crucial for any application, including Web APIs. Separating configuration from code allows for cleaner codebases, easier maintenance, and flexibility to change settings without redeploying your application. This guide will walk you through adding custom configuration to a .NET 8 Web API application.

Prerequisites

  • .NET 8 SDK installed on your machine.
  • A basic .NET 8 Web API Application. You can create one using the command:
  dotnet new webapi -o MyWebApiApp
Enter fullscreen mode Exit fullscreen mode

Step 1: Understanding the Default Configuration

When you create a new Web API project, appsettings.json and appsettings.Development.json files are included by default. The appsettings.json file is used to store configuration settings in JSON format, which the application reads at runtime.

Step 2: Adding Custom Configuration Sections

Let's add a custom configuration section to the appsettings.json file. Open appsettings.json and add the following:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ApiSettings": {
    "TwitterApiKey": "your-api-key",
    "TwitterApiSecret": "your-api-secret",
    "BearerToken": "your-bearer-token"
  }
}
Enter fullscreen mode Exit fullscreen mode

This adds a new section called ApiSettings where you can store your API credentials.

Step 3: Create a Strongly-Typed Configuration Class

To access the ApiSettings section in a strongly-typed manner, create a new class that matches the structure of the configuration section.

Create a new file ApiSettings.cs in your project:

namespace MyWebApiApp
{
    public class ApiSettings
    {
        public string TwitterApiKey { get; set; }
        public string TwitterApiSecret { get; set; }
        public string BearerToken { get; set; }
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 4: Register the Configuration in Program.cs

In .NET 8, the Program.cs file uses the minimal hosting model. You'll need to modify it to register your configuration class.

Open Program.cs and modify it as follows:

// Bind ApiSettings and add it to the services collection
builder.Services.Configure<ApiSettings>(builder.Configuration.GetSection("ApiSettings"));
Enter fullscreen mode Exit fullscreen mode

It should look like this:

using Microsoft.Extensions.Configuration;
using MyWebApiApp;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

// Bind ApiSettings and add it to the services collection
builder.Services.Configure<ApiSettings>(builder.Configuration.GetSection("ApiSettings"));

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseAuthorization();

app.MapControllers();

app.Run();
Enter fullscreen mode Exit fullscreen mode

This code binds the ApiSettings section of the configuration to the ApiSettings class and registers it with the dependency injection (DI) container.

Step 5: Access Configuration in Controllers or Services

Now that the configuration is registered, you can inject it into your controllers or services.

Injecting into a Controller

Open the WeatherForecastController.cs (or create a new controller) and modify it to use IOptions<ApiSettings>:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;

namespace MyWebApiApp.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class TwitterController : ControllerBase
    {
        private readonly ApiSettings _apiSettings;

        public TwitterController(IOptions<ApiSettings> apiSettings)
        {
            _apiSettings = apiSettings.Value;
        }

        [HttpGet("apikey")]
        public IActionResult GetApiKey()
        {
            return Ok(new
            {
                TwitterApiKey = _apiSettings.TwitterApiKey,
                TwitterApiSecret = _apiSettings.TwitterApiSecret,
                BearerToken = _apiSettings.BearerToken
            });
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Injecting into a Service

If you prefer to keep your controllers thin, you can create a service class:

Create a Service Interface and Class

Create a new interface ITwitterService.cs:

namespace MyWebApiApp.Services
{
    public interface ITwitterService
    {
        string GetApiKey();
        string GetApiSecret();
        string GetBearerToken();
    }
}
Enter fullscreen mode Exit fullscreen mode

Create the implementation TwitterService.cs:

using Microsoft.Extensions.Options;

namespace MyWebApiApp.Services
{
    public class TwitterService : ITwitterService
    {
        private readonly ApiSettings _apiSettings;

        public TwitterService(IOptions<ApiSettings> apiSettings)
        {
            _apiSettings = apiSettings.Value;
        }

        public string GetApiKey() => _apiSettings.TwitterApiKey;

        public string GetApiSecret() => _apiSettings.TwitterApiSecret;

        public string GetBearerToken() => _apiSettings.BearerToken;
    }
}
Enter fullscreen mode Exit fullscreen mode

Register the Service in Program.cs

Add the service to the DI container:

// ...

builder.Services.AddSingleton<ITwitterService, TwitterService>();

// ...
Enter fullscreen mode Exit fullscreen mode

Modify the Controller to Use the Service

Update TwitterController.cs:

using Microsoft.AspNetCore.Mvc;
using MyWebApiApp.Services;

namespace MyWebApiApp.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class TwitterController : ControllerBase
    {
        private readonly ITwitterService _twitterService;

        public TwitterController(ITwitterService twitterService)
        {
            _twitterService = twitterService;
        }

        [HttpGet("apikey")]
        public IActionResult GetApiKey()
        {
            return Ok(new
            {
                TwitterApiKey = _twitterService.GetApiKey(),
                TwitterApiSecret = _twitterService.GetApiSecret(),
                BearerToken = _twitterService.GetBearerToken()
            });
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 6: Run and Test the Application

Run your application using:

dotnet run
Enter fullscreen mode Exit fullscreen mode

Navigate to https://localhost:<port>/swagger to access the Swagger UI. You should see your TwitterController and the GetApiKey endpoint.

Try executing the GetApiKey endpoint to see your configuration values returned.

Step 7: Secure Your Sensitive Data

Important: Never store sensitive information like API keys or secrets in plain text within appsettings.json, especially in production environments.

Using User Secrets for Development

For development, you can use the Secret Manager to store sensitive data.

Run the following command in your project directory:

dotnet user-secrets init
Enter fullscreen mode Exit fullscreen mode

Add secrets using:

dotnet user-secrets set "ApiSettings:TwitterApiKey" "your-api-key"
dotnet user-secrets set "ApiSettings:TwitterApiSecret" "your-api-secret"
dotnet user-secrets set "ApiSettings:BearerToken" "your-bearer-token"
Enter fullscreen mode Exit fullscreen mode

These secrets will be stored securely on your machine and won't be checked into source control.

Modifying Program.cs to Include User Secrets

When in development mode, the configuration builder automatically includes user secrets. Ensure your Program.cs includes builder.Configuration as shown:

var builder = WebApplication.CreateBuilder(args);

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

// ...
Enter fullscreen mode Exit fullscreen mode

Conclusion

By following these steps, you've successfully added custom configuration to your .NET 8 Web API application. This setup allows you to manage your application settings efficiently while keeping your code clean and maintainable. Remember to secure sensitive information appropriately, especially in production environments.

Happy coding!


References:

This is a continuation from:
https://dev.to/iamrule/add-your-appsettingsjson-to-a-c-console-application-5gd6

Do your career a big favor. Join DEV. (The website you're on right now)

It takes one minute, it's free, and is worth it for your career.

Get started

Community matters

Top comments (2)

Collapse
 
mlprogress profile image
Mike Lerley • Edited

Thanks for this. I found elsewhere that if you inject IOptionsSnapshot instead of IOptions it will re-read the appsettings.json file every time and you can make changes to the json file without needing to restart the application.

Collapse
 
iamrule profile image
Roel

You could use that in combination with hot reload.

        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)

Enter fullscreen mode Exit fullscreen mode

Some thoughts were shared in this thread: stackoverflow.com/questions/510974...

A Workflow Copilot. Tailored to You.

Pieces.app image

Our desktop app, with its intelligent copilot, streamlines coding by generating snippets, extracting code from screenshots, and accelerating problem-solving.

Read the docs

👋 Kindness is contagious

Discover a treasure trove of wisdom within this insightful piece, highly respected in the nurturing DEV Community enviroment. Developers, whether novice or expert, are encouraged to participate and add to our shared knowledge basin.

A simple "thank you" can illuminate someone's day. Express your appreciation in the comments section!

On DEV, sharing ideas smoothens our journey and strengthens our community ties. Learn something useful? Offering a quick thanks to the author is deeply appreciated.

Okay