How to develop a customized setup supplier in ASP.NET Core 6


We utilize setup providers in ASP.NET Core to load configuration information into our application from one or more configuration sources. These suppliers can check out configuration data from command line arguments, environment variables, JSON or XML files, databases, Azure Secret Vault, and other sources– including your own custom-made sources.The ASP.NET Core configuration system consists of a set of classes that make it easier to manage the configuration settings of your application. This system is light-weight and extensible, and it offers a consistent way to store and retrieve setup settings for all ASP.NET Core applications.For custom-made configuration sources, you can create your own custom-made setup supplier in ASP.NET Core and attach it to the setup system. A custom setup service provider can assist you to reduce the intricacy associated with filling setup metadata from custom setup sources or external sources.This short article provides a discussion on how we can create a custom configuration provider in ASP.NET Core 6. To deal with the code examples supplied in this post, you should have Visual Studio 2022 set up in your system. If you don’t already have a copy, you can download Visual Studio 2022 here. Produce an ASP.NET Core 6 Web API task in Visual Studio 2022 First of all, let’s develop an ASP.NET Core task in Visual Studio2022.

Following these actions will develop a new ASP.NET Core 6 Web API project

in Visual Studio 2022: Release the Visual Studio 2022 IDE. Click on” Develop new project.”In the”Produce brand-new job”window, choose”ASP.NET Core Web API “from the list of design templates displayed. Click

  • Next. In the “Configure your new project”window, define the name and area for the brand-new project. Optionally inspect the”Place service and job in the same directory”check box, depending
  • on your preferences
  • . Click Next. In the “Extra Information”window shown next, select.NET 6.0 as the target structure from the drop-down list at the top. Leave the”Authentication Type”set to” None” (default). Guarantee that the check boxes”Enable
  • Docker,””Set up for HTTPS, “and”Enable Open API Assistance”are uncontrolled as we won’t be utilizing any of those features here. Click Create. We’ll utilize this ASP.NET Core 6 Web API project to produce a customized setup company in the subsequent areas of this article. Producing configuration service providers in ASP.NET Core 6 A configuration provider is generally a C# class that can retrieve setup information from a source(a file, a database

    , an external API, etc)and make it readily available to the application. There are many built-in configuration providers in ASP.NET Core consisting of JSON, XML, and database suppliers. Nevertheless, you can

    also create your customized configuration supplier if you need to.To create a custom-made configuration service provider, you should develop a class that extends the ConfigurationProvider class. Then, you need to override the Load()method to load the setup information from wherever it is stored and return the information as a key-value dictionary. Once you have actually developed your custom-made setup service provider, you can

    register it with ASP.NET Core by including it to the services collection in the Program.cs file. IDG Figure 1. The Option Explorer window of the finished application. Let’s now start developing a customized configuration supplier in ASP.NET 6 Core.

    custom config provider 01 The

    final service will comprise the following files: SecurityMetadata.cs CustomConfigurationSource.cs CustomConfigurationProvider.cs CustomConfigurationExtensions.cs CustomConfigurationController.cs We’ll learn about each of these files in

  • the areas that follow. In
  • addition, we will likewise compose code
  • in the Program.cs file to add the setup company and setup source to the default setup system of the ASP.NET Core runtime. The Solution Explorer window of the completed application ought to look like displayed in Figure 1 above.Create a class for security metadata in ASP.NET Core 6 We’ll keep API secrets and API secrets in a.json file and read it in the application we’ll be constructing here. We’ll not be utilizing any of these keys for verifying or authorizing requests in this example. API keys and API tricks are both used to

    validate access to an API. The primary distinction is that API secrets are public and can be accessed by anybody, whereas API secrets are private and must never ever be shared. An API key is an identifier that allows you to connect with an API in a safe way.API keys are used to restrict who

    can use an application and what they can do with it; i.e., they are utilized to confirm and license requests. API secrets are used to keep delicate details in your app. You can also use API tricks to create checksums and to secure and decrypt data.Create a class named SecurityMetadata in a file having the same name with a.cs extension and enter the following code. public class SecurityMetadata Create a class for a setup source in ASP.NET Core 6 Next, we’ll produce a setup source to initialize our

    custom-made configuration service provider. To do this, produce a new.cs submit called CustomConfigurationSource and give it the following code.

    public class CustomConfigurationSource: IConfigurationSource >home builder )

    Your custom configuration source should execute the IConfigurationSource interface. The IConfigurationSource user interface includes the Build approach where you should invoke your customized configuration provider.Create a custom setup supplier in ASP.NET Core 6 To check out configuration info from an external data source, you should implement your custom-made configuration supplier.
    Your custom-made configuration company is a regular C# class that extends the Microsoft.Extensions.Configuration.ConfigurationProvider abstract class and overrides
    the Load()technique as shown in the code listing given listed below. public class CustomConfigurationProvider: Microsoft.Extensions.Configuration.ConfigurationProvider Note how the ApiKey and ApiSecret are being saved in the dictionary instance named Data.Create a custom setup extensions class in ASP.NET Core 6 We’ll now create an extension method that will develop
    an circumstances of the CustomConfigurationSource class and return it. public static class CustomConfigurationExtensions Include the custom configuration source to Program.cs in
    ASP.NET Core 6 Now, get in the following line of code
    in the Program.cs file to add the custom configuration source to the
    collection of configuration providers.builder.Configuration.AddSecurityConfiguration(); The total code listing of the Program.cs file is provided listed below for your reference.using CustomConfigurationProvider;
    var home builder=WebApplication.CreateBuilder (args);// Include services
    to the container.builder.Configuration.AddSecurityConfiguration(); builder.Services.AddControllers (); builder.Services.AddEndpointsApiExplorer( ); builder.Services.AddSwaggerGen(); var app =builder.Build ();// Set up the HTTP demand pipeline.if (app.Environment.IsDevelopment () )app.UseSwagger( ); app.UseSwaggerUI (); app.UseAuthorization(); app.MapControllers(); app.Run(); Create a custom-made setup controller in
    ASP.NET Core 6 Lastly
    , produce a new API controller named CustomConfigurationController and replace the default produced code with the following code listing.
    [. Route(” api/ [controller].
    ” )]. [ApiController] public class CustomConfigurationController: ControllerBase Note how the IConfiguration circumstances is injected in the manufacturer of the CustomConfigurationController class.If you now run the application and hit the HttpGet endpoint of the CustomConfigurationController, you ought to see the configuration information being returned after it is read from the.json file in the file system. To check this, set a breakpoint in the HttpGet action method of

    the CustomConfigurationController as shown in Figure 2 below. IDG Figure 2. The ApiKey and ApiSecret are returned
    from the HttpGet action technique.
    In this post we have actually carried out a customized setup supplier that can read setup information from a.json file. Note that we have actually performed the application straight from the Visual Studio 2022 IDE and set a breakpoint to validate if the configuration information is being returned appropriately. Additionally, you might run the
    application using Postman, Fiddler, or the Swagger UI.
    Copyright © 2022 IDG Communications, Inc. Source

  • Leave a Reply

    Your email address will not be published. Required fields are marked *