Overview of Feature Management in .NET

One of many good features to have in a complex SaaS application is Feature Management, this allow a better control of the features for some audience, you can achieve this in many ways, simple as if statements to a complex Feature Management that I'll cover in this article.

This is particularly useful for A/B testing, gradual rollouts, and managing experimental or premium features without needing to redeploy the entire application.

What is Feature Management?

At its core, feature management refers to the ability to toggle features on and off based on configuration, user groups, or other business rules. This can be especially useful when you want to introduce new functionality gradually or limit certain features to specific user segments.

For example, you might want to release a new feature to only 10% of your user base initially, then expand as you gain confidence in the stability and value of the feature.

Using Feature Management in .NET

To access the .NET feature manager, your app must have references to the Microsoft.Azure.AppConfiguration.AspNetCore and Microsoft.FeatureManagement.AspNetCore NuGet packages.

The Microsoft.FeatureManagement.AspNetCore package makes it easy to implement feature flags in a .NET application. By installing this package and setting up configurations, you can dynamically control features in both ASP.NET Core and .NET applications.

Step 1: Install the Package

To get started, install the Microsoft.FeatureManagement.AspNetCore NuGet package:

dotnet add package Microsoft.FeatureManagement.AspNetCore        

Step 2: Configure Feature Flags

In your appsettings.json, define your features. For example:

{
... ,
  "FeatureManagement": {
    "NewFeature": true,
    "BetaFeature": false
  }
}        

Note that, if you not specify in the setup the section, the default will be under "FeatureManagement".

Step 3: Configure the application

In the Program.cs (considering using > .NET6) you need to add:

builder.Services.AddFeatureManagement(builder.Configuration.GetSection("MyFeatures"));        

Note that in this case we overwrite the standard section "FeatureManagement" to "MyFeatures".

Step 4: Using the feature management

There are many ways to use:

1. Use dependency injection to access IFeatureManager

using Microsoft.FeatureManagement;

public class SomeService
{
    private readonly IFeatureManager _featureManager;

    public SomeService(ILogger<SomeService> logger, IFeatureManager featureManager)
    {
        _featureManager = featureManager;
    }
}        

Then you can test to check if the feature is enable or not:

if (await featureManager.IsEnabledAsync("NewFeature"))
{
    // Run the following code
}        

You may want to add the string into a const variable in a class to avoid this code.

2. In Controllers using FeatureGate

With controllers, you can use the FeatureGate attribute to control whether a whole controller class or a specific action is enabled. The following ExampleController controller requires "NewFeature" to be on before any action the controller class contains can be executed:

using Microsoft.FeatureManagement.Mvc;

[FeatureGate("NewFeature")]
public class ExampleController : Controller
{
    ...
}        

3. Using middleware

You can also use feature flags to conditionally add application branches and middleware. The following code inserts a middleware component in the request pipeline only when "NewFeature" is enabled:

app.UseMiddlewareForFeature<MyBetaMiddleware>("NewFeature");        

Advanced Scenarios

.NET’s feature management also supports more advanced use cases, such as targeting specific users or groups. For instance, you can configure feature filters to target specific audiences or roll out features based on conditions like time windows, geographical location, or user roles.

Benefits of Feature Management

1. Controlled Rollouts: Gradually roll out features to a subset of users, ensuring you can handle issues with minimal impact.
2. A/B Testing: Experiment with different feature sets for different groups and gather data on what works best.
3. Experimentation: Enable or disable experimental features dynamically without the need for redeployment.
4. Flexibility: Easily turn off faulty features while keeping the rest of the application running smoothly.

Conclusion

Feature management in .NET is a valuable tool for any developer looking to build flexible, scalable, and maintainable applications. It empowers you to control feature rollouts, manage experiments, and adapt your application in real-time—all while maintaining stability and reducing risk.

By integrating feature flags in your .NET application, you can adopt modern software development practices like continuous delivery, increasing your ability to respond to market needs and user feedback faster.

In combination with a configuration server and IOptions pattern this is a very powerfull tool to manage your SaaS application on the fly without redeploying.