Use feature flags in an ASP.NET Core app

Beau HU

·January 10, 2025

·15 min read

Use feature flags in an ASP.NET Core app — Image Source: pexels

Feature flags act as flag switches that control the availability of features in your application. They allow you to enable or disable features dynamically without modifying the code. These flags are typically represented as boolean variables or key-value pairs in configuration files. By checking them during runtime, you can determine which code paths to execute.

Using feature flags in ASP.NET Core applications offers several advantages. They enable runtime modifications, allowing you to change application behavior without redeployment. You can perform dark deployments, where new features remain hidden until they are stable. Feature flags also support canary deployments, letting you release features gradually to ensure stability.

Feature flags improve deployment processes by reducing risks. They allow you to deploy incomplete features safely and disable problematic ones instantly. This approach minimizes disruptions and accelerates time-to-market. Tools like FeatBit simplify feature management, offering robust solutions for dynamic toggling. Explore FeatBit Github or FeatBit Docs to learn more about its capabilities.

Key Takeaways

Feature flags let you turn features on or off easily. You don’t need to change the code to do this.
They help lower risks when updating your app. You can add unfinished features safely and turn off broken ones fast. This makes the app work better for users.
To use feature flags, add the Microsoft.FeatureManagement.AspNetCore package. Set it up in your project to switch features on or off.
Use the IFeatureManager tool to check if features are on. This lets you show different pages depending on the feature’s status.
Remove old feature flags often to keep your code clean. This makes your app faster to update and easier to manage.

Setting up an ASP.NET Core project

Creating a new ASP.NET Core project

To begin, you need to create a new ASP.NET Core project. Open your terminal or IDE and run the following command to create a basic web application:

dotnet new web -n FeatureFlagDemo

This command generates a new ASP.NET Core project named FeatureFlagDemo. Once the project is created, navigate to the project directory:

cd FeatureFlagDemo

You can also create the project using Visual Studio. Select "Create a new project," choose "ASP.NET Core Web App," and follow the prompts to name and configure your project. After completing these steps, your project will be ready for further customization.

Preparing the project for feature management

To add feature management support to your ASP.NET Core project, you must install the Microsoft.FeatureManagement.AspNetCore NuGet package. Use one of the following commands to install it:

Install-Package Microsoft.FeatureManagement.AspNetCore -Version 2.6.1

dotnet add package Microsoft.FeatureManagement.AspNetCore

After installation, configure the package in your Program.cs file. Add the following line to register feature management services:

builder.Services.AddFeatureManagement();

This setup ensures that the Microsoft.FeatureManagement library manages the lifecycle of your feature flags. If you want to use a custom configuration section for your feature flags, you can specify it like this:

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

These steps prepare your ASP.NET Core project for dynamic feature toggling. You can now control features without restarting the application, making your project more flexible and efficient.

Installing and configuring Microsoft.FeatureManagement

Installing the Microsoft.FeatureManagement library

To start using feature flags in your ASP.NET Core project, you need to install the Microsoft.FeatureManagement.AspNetCore package. This feature management library simplifies the process of controlling feature availability dynamically. It allows you to manage features without redeploying code, reducing deployment risks and enabling strategies like A/B testing and incremental rollouts. Additionally, it integrates seamlessly with tools like Azure App Configuration, making it a powerful choice for building scalable systems.

Follow these steps to install the library:

Use the NuGet Package Manager in Visual Studio or run the following command in your terminal:
```
dotnet add package Microsoft.FeatureManagement --version 1.0.0-preview-009000001-1251
```
Verify that your project file (.csproj) includes the Microsoft.FeatureManagement package reference.
Add the required services to your dependency injection container by including the following line in your Program.cs file:
```
builder.Services.AddFeatureManagement();
```

This installation process ensures that your project is ready to leverage the feature management capabilities of the library.

Configuring feature flags in appsettings.json

After installing the library, you need to define your feature flags in the appsettings.json file. This file acts as the central configuration point for your application. Use the FeatureManagement section to list your feature flags and their statuses. For example:

{
  "FeatureManagement": {
    "CreateStadium": false,
    "EditStadium": true,
    "DeleteStadium": false
  }
}

In this example, the EditStadium feature is enabled, while the others are disabled. This structure allows you to toggle features easily by updating the configuration file.

Registering feature management services in the project

To enable feature flag management in your ASP.NET Core application, you must register the necessary services. Add the following code to your Program.cs file:

builder.Services.AddFeatureManagement();

This step integrates the Microsoft.FeatureManagement library into your project. It ensures that the library manages the lifecycle of your feature flags effectively. By doing this, you gain access to advanced feature management capabilities, such as dynamic toggling and continuous integration support.

Note: Always test your feature flags in a development environment before deploying them to production. This practice minimizes risks and ensures smooth feature rollouts.

With these steps completed, your project is now equipped to handle feature flag management efficiently.

Implementing feature flags in controllers

Using the IFeatureManager interface

The IFeatureManager interface plays a crucial role in implementing feature flags in your controllers. It allows you to check the status of a feature toggle dynamically during runtime. For example, you can use it to determine whether a specific feature, such as NewFeature, is enabled. Based on the result, your controller can serve different views or responses.

Consider a scenario where your HomeController uses IFeatureManager to check the NewFeature flag. If the flag is enabled, the controller serves a NewFeatureView. Otherwise, it defaults to a DefaultView. This approach ensures dynamic feature control without altering the core logic of your application. By leveraging IFeatureManager, you can enable and disable features seamlessly, enhancing user experience and supporting safer rollouts.

Checking feature flags in controller actions

When implementing feature flags in controller actions, you should follow best practices to ensure smooth functionality. Use the [FeatureGate] attribute to enable feature-based access for specific actions or controllers. This attribute accepts an array of feature toggles and grants access if any of them are enabled.

Additionally, consider using the IFeatureManager interface to check feature flags directly within your controller actions. For example, you can create an action that verifies whether a feature is enabled and returns appropriate responses. Deploying new features in a disabled state (dark deployments) minimizes risks and supports safer rollouts. You can also implement the IDisabledFeaturesHandler interface to customize responses when features are disabled.

Example: Implementing a dotnet flag switch in an API endpoint

To demonstrate how to implement a dotnet flag switch in an API endpoint, follow these steps:

Install the required package:

dotnet add package Microsoft.FeatureManagement.AspNetCore

Configure feature flags in appsettings.json:

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

Use feature toggles in a controller action:

public class FeatureController : Controller
{
    private readonly IFeatureManager _featureManager;

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

    [HttpGet("/feature")]
    public async Task<IActionResult> GetFeature()
    {
        if (await _featureManager.IsEnabledAsync("NewFeature"))
        {
            return Ok("New Feature is enabled!");
        }
        return Ok("New Feature is disabled.");
    }
}

This example shows how to use feature toggles to enable and disable features dynamically. By integrating feature flags into your API endpoints, you can achieve feature toggling with minimal effort, ensuring flexibility and safer rollouts.

Using the FeatureGate attribute for feature toggling

Overview of the FeatureGate attribute

The FeatureGate attribute simplifies feature toggling in ASP.NET Core applications. It allows you to wrap entire controllers or specific endpoints in feature toggles. By doing so, you can dynamically control access to features based on their status. For example, if a feature flag is disabled, the FeatureGate attribute can restrict access and return a 404 error to users.

This attribute provides flexibility in managing features. You can apply it to individual action methods or entire controllers. It ensures that only enabled features are accessible, reducing the risk of exposing incomplete or experimental functionality. With FeatureGate, you can control the execution of specific actions or entire MVC controllers, making it a powerful tool for feature management.

Applying FeatureGate to controllers and actions

You can apply the [FeatureGate] attribute to controllers, action methods, or even globally in your ASP.NET Core project. It accepts an array of feature flags and grants access if any of the specified flags are enabled. This makes it easy to manage feature toggles at different levels of your application.

For instance, applying [FeatureGate] at the class level restricts access to all action methods within that controller. If you annotate a controller class with [FeatureGate(FeatureFlags.FlagController)], the controller's actions will only execute when the FlagController feature is enabled. Similarly, you can use the attribute on individual action methods to control access to specific endpoints.

This approach ensures that your application remains modular and secure. You can enable or disable features without modifying the underlying code, streamlining your development and deployment processes.

Example: Restricting access to features with FeatureGate

Here’s an example of how to use the FeatureGate attribute to restrict access to features:

Applying FeatureGate to a controller:

[FeatureGate(ApplicationFeatures.StadiumsList)]
public class StadiumsController : Controller {}

Applying FeatureGate to an action method:

[FeatureGate(ApplicationFeatures.StadiumsList)]
public IActionResult Index() { return View(); }

Using multiple feature flags:

[FeatureGate(Microsoft.FeatureManagement.RequirementType.Any, 
             ApplicationFeatures.StadiumsList, 
             ApplicationFeatures.CreateStadium)]
public class StadiumsController : Controller {}

In these examples, the FeatureGate attribute dynamically controls access based on the status of feature toggles. This ensures that users only interact with features that are ready for use, improving the overall user experience.

Advanced feature management and best practices

Using feature filters for dynamic toggling

Feature filters in ASP.NET Core allow you to enable or disable features dynamically based on specific conditions. These filters provide flexibility and control, making them essential for complex feature flag management. Here are some common types of feature filters you can use:

Boolean Filter: The simplest form, enabling or disabling a feature with a true/false value.
Time-Based Filter: Activates features within a defined time window, ideal for time-sensitive launches.
Percentage Filter: Gradually rolls out features by enabling them for a percentage of requests. This approach minimizes risks during deployment.
Targeting Filter: Enables features for specific user groups, ensuring a tailored experience for targeted users.

You can also create custom filters if the built-in options do not meet your needs. For example, you might design a filter that activates features based on geographic location or device type. These filters help you manage features dynamically, ensuring a smooth user experience.

Managing feature flags in production environments

Managing feature flags in production requires careful planning to avoid issues. Follow these strategies to maintain control and reduce risks:

Integrate your feature flag system with logging tools to monitor feature usage and diagnose problems quickly.
Regularly audit and remove unused flags to prevent technical debt. Use automated tools to streamline this process.
Establish clear naming conventions for flags to improve collaboration and reduce confusion.
Document the lifecycle of each flag, including its purpose and expected removal date. This transparency helps teams stay aligned.

Consider the impact of flag removal on your users. Engage product managers to evaluate the relevance of each flag and ensure smooth transitions. These practices keep your codebase clean and your application stable.

Best practices for feature management in ASP.NET Core

Adopting best practices ensures effective feature management in your ASP.NET Core applications. Here are some key recommendations:

Use descriptive names for flags to clarify their purpose.
Group related flags into logical categories for better organization.
Document each flag's usage and expected behavior.
Test thoroughly to avoid unexpected issues during deployment.
Monitor performance to identify and resolve potential bottlenecks.

Best Practice	Description
Define Clear Criteria	Establish rules for determining which version a user should access.
Document Each Version	Maintain detailed documentation for all active versions.
Monitor Performance	Track the performance of each version to identify issues.
Plan for Sunset	Gradually phase out older versions when they are no longer needed.

By following these best practices, you can minimize risks, manage performance issues effectively, and maintain a healthy codebase.

Cleaning up unused feature flags to reduce technical debt

Unused feature flags can accumulate over time, creating unnecessary complexity in your codebase. This buildup increases technical debt, making your application harder to maintain. Cleaning up these flags ensures your project remains efficient and manageable.

You should start by identifying unused feature flags. Review your codebase and configuration files to locate flags that no longer serve a purpose. Collaborate with your team to confirm whether these flags are still relevant. Tools like static code analyzers can help you pinpoint unused flags quickly.

Once you identify unused flags, remove them systematically. Begin with your configuration files, such as appsettings.json, and delete the corresponding entries. Next, clean up any related code paths. Test your application thoroughly after each removal to ensure no unintended side effects occur.

Integrating this cleanup process into your workflow aligns with trunk-based development. This development model emphasizes maintaining a clean and stable main branch. By regularly removing unused feature flags, you reduce clutter and improve code quality. This practice also supports faster deployments and minimizes the risk of introducing bugs.

To prevent future issues, establish a lifecycle for feature flags. Assign each flag a clear purpose and expiration date. Document these details to keep your team informed. Regularly audit your flags as part of your trunk-based development strategy. This proactive approach helps you avoid accumulating technical debt.

Cleaning up unused feature flags is not just about reducing clutter. It ensures your application remains scalable and easy to maintain. By adopting these practices, you can keep your codebase healthy and aligned with trunk-based development principles.

Feature flags empower you to control application behavior dynamically, reducing deployment risks and enabling strategies like gradual rollouts and A/B testing. They enhance flexibility, allowing you to test features in production without impacting users.

To implement feature flags with Microsoft.FeatureManagement, follow these steps:

Install the Microsoft.FeatureManagement.AspNetCore NuGet package using the command:
Install-Package Microsoft.FeatureManagement.AspNetCore -Version 2.6.1.
Configure the feature management service in Program.cs by adding:
builder.Services.AddFeatureManagement();.
Optionally, specify a custom settings name:
builder.Services.AddFeatureManagement(Configuration.GetSection("MyFeatureFlags"));.
Define features and their states in appsettings.json.
Use the feature tag helper in Razor Pages to conditionally render HTML.

To enable feature management, register the necessary services in your application's startup configuration. Add this code to Program.cs:
builder.Services.AddFeatureManagement();.

Explore advanced techniques like feature filters, centralized platforms, and performance monitoring. Adopt best practices such as defining feature lifecycles, managing dependencies, and integrating user feedback. These strategies ensure effective feature management and a seamless user experience.

FAQ

What are feature flags, and why should you use them?

Feature flags are switches that let you enable or disable features in your app without changing the code. They help you test new features, perform gradual rollouts, and reduce deployment risks. You can use them to improve flexibility and ensure smoother user experiences.

Can you use feature flags in production environments?

Yes, you can use feature flags in production. They allow you to test features with specific users or groups. You can monitor performance and user feedback before a full release. This approach minimizes risks and ensures stability during deployments.

How do you define feature flags in an ASP.NET Core app?

You define feature flags in the appsettings.json file under the FeatureManagement section. For example:

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

This configuration enables or disables features dynamically.

What is the difference between the FeatureGate attribute and IFeatureManager?

The FeatureGate attribute restricts access to controllers or actions based on feature flags. It works declaratively. The IFeatureManager interface checks feature flags programmatically. Use it when you need more control over feature toggling logic in your code.

How can you clean up unused feature flags?

Review your codebase and configuration files to identify unused flags. Remove them systematically, starting with appsettings.json. Test your app after each removal. Regular audits and documentation help prevent unused flags from accumulating, reducing technical debt and keeping your codebase clean.