Feature flags enable you to create a new piece of functionality in the main code branch, but behind a mask - so the end user doesn’t see the change. This means that you can decide at a later date to turn the feature on, or off. For example, say you wanted to make a change the colour of your web-site; or maybe you wanted to introduce an “Express Checkout” button; you can create these behind a feature flag, meaning that, should sales suddenly plummet when these changes are released, you can simply flick a switch to turn them off.
In this post, I’m going to cover the most basic usage of a feature flag. We’ll create a new web-site and, where a feature flag is turned on, we’ll show a button; and where it is not, we won’t. Before we start on the specifics, create a blank Asp.Net Core MVC project.
1. Add NuGet packages
The concept of feature flags exist outside of Microsoft. In fact, Feature Flags are just the idea of enabling functionality based on a setting, so there was probably one in the first computer program ever written. In this post, we’re talking about the implementation of this concept that’s available from Microsoft for Asp.Net Core.
The first step, as with more Microsoft libraries these days, is NuGet:
Install-Package Microsoft.FeatureManagement.AspNetCore
2. Add to DI
In Startup.cs, we’ll need to add the feature into the IoC. In the `ConfigureServices` method, add the following code:
services.AddFeatureManagement();
3. Config appsettings.json
Add the following section to appsettings.json:
"FeatureManagement": {
"MyFeature": true
}
All we’re doing here is building up a key value pair underneath the “FeatureManagement” header. These settings can be more complex, but all we’re doing here is saying that our feature is on.
4. Inject the Functionality
Now that we’ve registered this in the IoC (using AddFeaturemanagement) we can inject it into our controller or service; for example:
public MyService(IFeatureManager featureManager)
{
\_featureManager = featureManager;
}
Then you can simply check whether the feature is enabled:
if (await featureManager.IsEnabledAsync("MyFeature")) { // Run the following code }
There is an intrinsic flaw with using magic strings like this - if you rename them, you could miss one. Microsoft recommend using an enum, such as this:
public enum MyFeatureFlags { FeatureA, FeatureB, FeatureC }
Which would enable you to reference it like this:
if (await featureManager.IsEnabledAsync(nameof(MyFeatureFlags.FeatureA)))
5. Access to controllers and views
You can hide an entire controller behind a flag; for example:
[FeatureGate(MyFeatureFlags.FeatureA)]
public class HomeController : Controller
{ ... }
You can use these on specific controller actions, too.
We did say at the start of this post that we’d display a button when a flag was on, so let’s see what that would look like in the view; after all, whilst the rest of this is useful, the most likely thing that you’ll want to do in enabling or disabling a feature is change what the user can see. The following code would only show a button if “MyFeature” is on:
[code lang=“html”]
A slight caveat here, in order to use this HTML tag, you'll need to modify your ```
_ViewImports.cshtml
file:
@addTagHelper \*, Microsoft.AspNetCore.Mvc.TagHelpers
@addTagHelper \*, Microsoft.FeatureManagement.AspNetCore
Summary and Notes
Seems pretty smooth to me. There are other feature flag managers out there; and, to be honest, it’s not like you couldn’t create your own in an hour or so, but this one struck me as a very neat option.
Also, because it’s from Microsoft, you can use Azure App Configuration to manage the flags; this gives you a proper UI to manage the flags. Obviously, if they’re in the appsetting.json, you have a number of other options, but if you’re using Azure, why not take advantage.
References
https://docs.microsoft.com/en-us/azure/azure-app-configuration/use-feature-flags-dotnet-core
https://docs.microsoft.com/en-us/dotnet/api/microsoft.featuremanagement?view=azure-dotnet-preview