Search  
Always will be ready notify the world about expectations as easy as possible: job change page
Aug 23, 2022

Building a custom Configuration Provider in .NET 6

Author:
Luis Rodrigues
Source:
Views:
2357

Suppose we are building a web api that contains a route to send notification messages to other systems.

For security matters, before sending any notification message, we need to provide some credentials to these systems to they accept our messages.

However, these credentials are stored in an external data source, and not in our appSettings.json. How can we load these credentials as application configuration properties?

A good approach for that is to create a custom Configuration Provider. Customs Configuration Providers from .NET. It allows us to read and load settings from external data sources.

This article presents three simple steps to read settings from a local file (notification_values.json).

1. Implement a Configuration Provider

To read settings from an external data source we need to implement a new class that inherits the ConfigurationProvider abstract class.

This abstract class is part of Microsoft.Extensions.Configuration namespace.

See the code below:

 1   public class NotificationApiConfigurationProvider : Microsoft.Extensions.Configuration.ConfigurationProvider
 2   {
 3       public override void Load()
 4       {
 5          var fileContent = File.ReadAllText(@"notification_values.json");
 6          var content = JsonSerializer.Deserialize<Notification>(fileContent, new JsonSerializerOptions
 7          {
 8              PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
 9          });
10
11          if(content == null) return;
12
13          Data = new Dictionary<string, string>
14          {
15              {"Notification:ApiKey", content.ApiKey},
16              {"Notification:Url", content.Url},
17              {"Notification:Method", content.Method}
18          };
19      }
20   }

The class NotificationApiConfigurationProvider inherits methods and properties from the ConfigurationProvider class. However, to read and load the configurations from a local file, we need to override the Load method from ConfigurationProvider abstract class.

From the Load method, after reading the properties from an external source, they will store in the Data property (see line 13).

Now, we need to create a source to initiate this new configuration provider.

2. Implement a Configuration Source

The IConfigurationSource interface contains the Build method. With this method, we can apply all we need to initiate our custom configuration provider.

See the code below:

public class NotificationApiConfigurationSource : IConfigurationSource
{
    public IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        return new NotificationApiConfigurationProvider();
    }
}

For this sample, I created the NotificationApiConfigurationSource class that inherits the IConfigurationSource interface.

As you can see this interface has only one method, the Build method. Basically, the method implementation was to return a new instance from our custom configuration provider, that will be available when the application starts.

At this moment, we have the custom configuration provider and the configuration source ready.

The next step is about how to read the configuration in our application.

3. Load settings from Configuration Provider

The code below belongs to the Program class. Take a look at line 4:

 1   using ConfigurationProvider.API.Extensions;
 2
 3   var builder = WebApplication.CreateBuilder(args);
 4   builder.Configuration.AddNotificationConfiguration();
 5
 6   // Add services to the container.
 7
 8   builder.Services.AddControllers();
 9   // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
10   builder.Services.AddEndpointsApiExplorer();
11   builder.Services.AddSwaggerGen();
12
13   var app = builder.Build();
14
15   // Configure the HTTP request pipeline.
16   if (app.Environment.IsDevelopment())
17   {
18       app.UseSwagger();
19       app.UseSwaggerUI();
20   }
21
22   app.UseHttpsRedirection();
23
24   app.UseAuthorization();
25
26   app.MapControllers();
27
28   app.Run();

As you can see in line 4, the extension method AddNotificationConfiguration is called at this moment.

This extension method from the IConfigurationBuilder interface will create a new instance from the NotificationApiConfigurationSource class.

using ConfigurationProvider.API.CustomProvider;

namespace ConfigurationProvider.API.Extensions;

public static class ConfigurationBuilderExtensions
{
    public static IConfigurationBuilder AddNotificationConfiguration(this IConfigurationBuilder builder)
    {
        builder.Add(new NotificationApiConfigurationSource());
        return builder;
    }
}

Basically, a new instance of NotificationApiConfigurationSource class is created. Then, when the application starts the custom provider will read all settings from the external data source and let them available in the application.

Now, the configuration can easily be read from any part of the Web API. For example, the code below shows how to read from a Controller class.

using ConfigurationProvider.API.Model;
using Microsoft.AspNetCore.Mvc;

namespace ConfigurationProvider.API.Controllers;

[ApiController]
[Route("[controller]")]
public class NotificationController : ControllerBase
{
    private readonly IConfiguration _configuration;

    public NotificationController(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    [HttpGet]
    public IActionResult Get()
    {
        var notification = new Notification
        {
            ApiKey = _configuration["Notification:ApiKey"],
            Method = _configuration["Notification:Url"],
            Url = _configuration["Notification:Method"]
        };

        return Ok(notification);
    }
}

I hope that this can be helpful for you! Happy coding!

Similar
Oct 20, 2022
Author: Vishal Yelve
ASP.NET Core MVC is a web development framework, widely used by developers around the word, to develop web applications. These web applications have proven to be vulnerable to attacks from different sources, though, and it is our responsibility to safeguard...
Apr 14
I recently migrated this blog from WordPress to a custom Nuxt site. I moved from WordPress to have more control over the blog and not have to rely on plugins to do everything. It’s worked out really well but there...
Apr 16, 2022
Author: Matthew MacDonald
Sometimes it’s the little things that count.When .NET 6 dropped this November, a few top-line items grabbed all the attention. I’m talking about C# 10, hot reload, Blazor’s AOT compilation, and some serious inner loop performance improvements. All of them...
Aug 18, 2020
Author: Shawn Wildermuth
Key Takeaways Developers keep moving to Single Page Applications (SPAs), though client-side development doesn’t mean you need a SPA in every case. There are several ways to use SPA frameworks with ASP.NET Core, including...
Send message
Email
Your name
*Message


© 1999–2024 WebDynamics
1980–... Sergey Drozdov
Area of interests: .NET Framework | .NET Core | C# | ASP.NET | Windows Forms | WPF | HTML5 | CSS3 | jQuery | AJAX | Angular | React | MS SQL Server | Transact-SQL | ADO.NET | Entity Framework | IIS | OOP | OOA | OOD | WCF | WPF | MSMQ | MVC | MVP | MVVM | Design Patterns | Enterprise Architecture | Scrum | Kanban