Simplifying Configuration Management in C# with Strongly-Typed Settings💪

Hussein Mhadi

·

Follow

3 min read

·

Apr 2, 2024

--

Listen

Share

IOptions<T> in C# simplifies accessing configuration settings by binding them to strongly-typed objects. It’s commonly used in ASP.NET Core to inject configuration into services, improving code readability and maintainability.

Here’s a more detailed explanation:

1. Strongly-Typed Configuration : Instead of dealing with configuration settings as key-value pairs or strings, IOptions<T> allows you to define a strongly-typed configuration class ( T ) that represents your application settings. This makes your configuration code type-safe, reducing the risk of runtime errors.

2. Binding Configuration : With IOptions<T> , you can bind configuration settings from various sources (such as JSON files, environment variables, or command-line arguments) to instances of your configuration class ( T ). ASP.NET Core provides built-in mechanisms for binding configuration, making it easy to manage settings for different environments (development, staging, production, etc.).

3.Dependency Injection : One of the key benefits of IOptions<T> is its integration with the ASP.NET Core dependency injection system. By injecting IOptions<T> into your services or components, you can access configuration settings directly within your code. This promotes modular design and testability, as your services don’t need to directly access the configuration system.

We will take an example of setting up and configuring the JWT to see the benefits of it

    public class JWTStting
    {
        public const string SectionName = "JwtSetting";
        public string? securt { get; init; }
        public string? issuer { get; init; }
        public int expires { get; init; } = 1;

    }

 "JwtSetting": {
    "securt": "My Securt-Key-For-Config",
    "issuer": "BloomTask",
    "expires": 60
  }

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
  
 public static class DependencyInjection
    {
        public static IServiceCollection AddInfustracture(this IServiceCollection services, ConfigurationManager configuration)
        {
            services.Configure<JWTStting>(configuration.GetSection(JWTStting.SectionName));
            services.AddSingleton<IJWTGenrator, JWTGenrator>();
            return services;
        }
    }

 public class JWTGenrator : IJWTGenrator
    {
        private readonly JWTStting _jwtsetting;
        public JWTGenrator(IOptions<JWTStting> jwtsetting)
        {
            _jwtsetting = jwtsetting.Value;
        }
        public string GenrateToken(Guid id, string firstname, string lastname)
        { 
            var singCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtsetting.securt)), SecurityAlgorithms.HmacSha256);
            var claim = new[]
            {
                new Claim(JwtRegisteredClaimNames.GivenName,firstname),
                new Claim(JwtRegisteredClaimNames.FamilyName,lastname),
                new Claim(JwtRegisteredClaimNames.Jti , Guid.NewGuid().ToString()),
                new Claim(JwtRegisteredClaimNames.UniqueName ,id.ToString()),
 
             };

            var securityKey = new JwtSecurityToken(

               issuer: _jwtsetting.issuer,
               expires: DateTime.Now.AddHours(_jwtsetting.expires),
               claims: claim,
               signingCredentials: singCredentials
             );


            return new JwtSecurityTokenHandler().WriteToken(securityKey);


        }
    }

In summary

IOptions<T> simplifies configuration management in C# applications by providing a strongly-typed, dependency-injected mechanism for accessing configuration settings. It promotes clean, maintainable code and enhances the flexibility of your application’s configuration.