Using Feature Flags in .Net 6

Topics covered in this article are…

---

What are Feature Flags?
Setting up Feature Flags
Defining Feature Flags
Using IFeatureManager with Dependency Injection
Defining Constant
Way to check Feature Flags
Conclusion

What are Feature Flags?

---

Setting up Feature Flags:

---

https://learn.microsoft.com/en-us/visualstudio/ide/create-new-project?view=vs-2022

using Microsoft.FeatureManagement;

builder.Services.AddFeatureManagement();

using Microsoft.FeatureManagement;

var configuration = new ConfigurationBuilder()
   .AddJsonFile("appsettings.json")
   .Build()
   .GetSection("FeatureManagement");
​​

///   or
​
builder.Services
   .AddFeatureManagement(builder.Configuration.GetSection("FeatureManagement"));

using Microsoft.FeatureManagement;

builder.Services.AddFeatureManagement()
   .AddFeatureFilter<PercentageFilter>();

Defining Feature Flags:

---

{"FeatureManagement": {
       "FirstFeature": true, // Feature flag set to on
       "SecondFeature": false, // Feature flag set to off
       "ThirdFeature": {
           "EnabledFor": [
               {
                   "Name": "Percentage",
                   "Parameters": {
                       "Value": 50
                   }
               }
           ]
       }
   }
}

FirstFeature is on.
SecondFeature is off.
ThirdFeature specifies a filter named Percentage with a Parameters property. This filter is configurable and sets a 50-percent probability for the ThirdFeature flag to be on. For a detailed guide on using feature filters, you can check out “Use feature filters to enable conditional feature flags.”

Using IFeatureManager With Dependency Injection:

---

Add an argument of type IFeatureManager to the constructor of your controller.
The runtime will automatically provide an implementation of IFeatureManager when calling the constructor.

using Microsoft.FeatureManagement;

public class MyController : Controller
{
   private readonly IFeatureManager _featureManager;
   public MyController(IFeatureManager featureManager)
   {
       _featureManager = featureManager;
   }
}

Defining Constant:

---

public static class MyFeatureFlags
{
   public const string FirstFeature = "FirstFeature";
   public const string SecondFeature = "SecondFeature";
   public const string ThirdFeature = "ThirdFeature";
}

Way to Check Feature Flags:

---

1) Controller-Based:

---

In C# code

public MyController(IFeatureManager featureManager)
       {
           _featureManager = featureManager;
       }

        public async Task<IActionResult> Index()
       {
           if (await _featureManager.IsEnabledAsync(MyFeatureFlags.FirstFeature))
           {
               return View();
           }
           return RedirectToAction("Error");
       }​

       [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
       public IActionResult Error()
       {
           return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
       }
   }

In Controller Action

using Microsoft.FeatureManagement.Mvc;

[FeatureGate(MyFeatureFlags.FirstFeature)]
public class MyController : Controller
{
   // Actions in this controller require FirstFeature to be enabled to run
   // If FirstFeature is off, the actions will be blocked
   // You can define multiple actions in this controller
   // All actions will follow the same FirstFeature condition.
}

using Microsoft.FeatureManagement.Mvc;
public class MyController : Controller
{
   // This action requires FirstFeature to be enabled to run
   // If FirstFeature is off, this action will be blocked
   [FeatureGate(MyFeatureFlags.FirstFeature)]
   public IActionResult Index()
   {
       return View();
   }

   // Other actions in this controller...
}

In MVC View

Open the _ViewImports.cshtml file located in the “Views” directory.
Add the feature manager tag helper to this file:

@addTagHelper *, Microsoft.FeatureManagement.AspNetCore

Now you can use the <feature> tag in your views to show content based on whether a feature flag is enabled:

<feature name="FirstFeature">
   <p>This can only be seen if 'FirstFeature' is enabled.</p>
</feature>

<feature name="FirstFeature" negate="true">

   <p>This will be shown if 'FirstFeature' is disabled.</p>

</feature>

<feature name="FirstFeature, SecondFeature" requirement="All">
   <p>This can only be seen if 'FirstFeature' and 'SecondFeature' are enabled.</p>

</feature>

<feature name="FirstFeature, SecondFeature" requirement="Any">
   <p>This can be seen if 'FirstFeature', 'SecondFeature', or both are enabled.</p>
</feature>

In MVC Filter

using Microsoft.FeatureManagement.FeatureFilters;

public void ConfigureServices(IServiceCollection services)
{
   services.AddMvc(options => {

       // Add ThirdPartyActionFilter as an MVC filter for the feature flag FirstFeature

       options.Filters.AddForFeature<ThirdPartyActionFilter>(MyFeatureFlags.FirstFeature);
   });
}

In Middleware

app.UseMiddlewareForFeature<ThirdPartyMiddleware>(MyFeatureFlags.FirstFeature);

app.UseForFeature(featureName, appBuilder => {
   appBuilder.UseMiddleware<T>();
});

2) Minimal API:

---

public class FeatureFlagEndpoint : IEndpointFilter
{
   public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
   {

       var endpoint = context.HttpContext.GetEndpoint();

       var methodName = string.Empty;

       if (endpoint != null)
       {

           // Access endpoint metadata or other information as needed


           if (endpoint.Metadata.GetMetadata<EndpointNameMetadata>() is { } nameMetadata)

           {
               methodName = nameMetadata.EndpointName;

           }

       }

       var featureFlag = context.HttpContext.RequestServices.GetRequiredService<IFeatureManager>();

       var isEnabled = await featureFlag.IsEnabledAsync($"Api_{methodName}");

       if (!isEnabled)

       {
           return Results.NotFound();
       }
       return await next(context);
   }

}

in above code, implementation of the FeatureFlagEndpoint class, which is an IEndpointFilter used in a Minimal API with Microsoft Feature Management.
The FeatureFlagEndpoint class implements the IEndpointFilter interface, which means it needs to provide an InvokeAsync method. In the InvokeAsync method, the endpoint being accessed is retrieved from the EndpointFilterInvocationContext using context.HttpContext.GetEndpoint()
The feature flag’s state is obtained using await featureFlag.IsEnabledAsync(featureFlagName), and if the feature is not enabled (isEnabled is false), the code returns a Results.NotFound() result. This effectively prevents access to the endpoint, and a 404 response will be returned.
If the feature is enabled, the next(context) is called, which allows the request to proceed through the pipeline and reach the endpoint’s handler.
FeatureFlagEndpoint class acts as a filter for API endpoints, allowing or denying access based on the state of the corresponding feature flag. If the feature flag is disabled for a specific endpoint, the endpoint will not be accessible, and a 404 response will be returned. Otherwise, the request will be allowed to proceed to the endpoint’s handler.

using FeatureFlagsWithMinimulAPI_Demo;
using Microsoft.FeatureManagement;
using Microsoft.FeatureManagement.FeatureFilters;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container

builder.Services.AddEndpointsApiExplorer();

builder.Services.AddFeatureManagement()
   .AddFeatureFilter<PercentageFilter>();

var app = builder.Build();

app.MapGet("/newweatherforecast", () =>
{
   var forecast = Enumerable.Range(1, 10).Select(index =>
       new WeatherForecastNew
       (
           DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
           Random.Shared.Next(-20, 55)
       ))
       .ToArray();
   return forecast;
})

.AddEndpointFilter<FeatureFlagEndpoint>()
.WithName("NewGetWeatherForecast")
.WithOpenApi();

app.Run();

// create WeatherForecastNew object
public class WeatherForecastNew
{
   public DateOnly Date { get; set; }
   public int TemperatureC { get; set; }
   public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

   public WeatherForecastNew(DateOnly date, int temperatureC)
   {
       Date = date;
       TemperatureC = temperatureC;
   }
}

​

in this above code, Feature Management services are added to the services collection, and the PercentageFilter is registered using builder.Services.AddFeatureManagement().AddFeatureFilter<PercentageFilter>().
create API defines an GET endpoint at the path “/newweatherforecast”. When accessed, it returns an array of WeatherForecastNew objects. The WeatherForecastNew the class represents a weather forecast with properties for date and temperature in Celsius and Fahrenheit.
Feature flags are applied to the endpoint using app.MapGet().AddEndpointFilter<FeatureFlagEndpoint>(). The FeatureFlagEndpoint class is a custom feature filter that enables or disables this endpoint based on the feature flag’s configuration.
The feature flag is named “NewGetWeatherForecast” and is defined in the Microsoft Feature Management configuration. By using .WithName(“NewGetWeatherForecast”), the feature flag is associated with this endpoint.

"FeatureManagement": {
   "Api_NewGetWeatherForecast": {
     "EnabledFor": [
       {
         "Name": "Percentage",
         "Parameters": {
           "Value": 50
        }
      }
    ]
  }
}

“Api_NewGetWeatherForecast”: The name of the feature flag. This name should match the feature flag associated with the endpoint in the code.
“EnabledFor”: This array contains a single element, which specifies the filter used to enable the feature flag.
“Name”: “Percentage”: Specifies that the feature flag should be enabled using the PercentageFilter.
“Parameters”: { “Value”: 50 }: The PercentageFilter requires a parameter called “Value”, which represents the percentage of requests for which the feature should be enabled. In this case, the feature “Api_NewGetWeatherForecast” is enabled for 50% of the requests.

Conclusion:

---

Do You Need more information?

For any further information / query regarding Technology, please email us at info@varianceinfotech.in
OR call us on +1 630 534 0223 / +91-7016851729, Alternately you can request for information by filling up Contact Us