quickstart-feature-flag-aspnet-core.md

title	description	author	ms.service	ms.devlang	ms.custom	ms.topic	ms.date	ms.author
Quickstart for adding feature flags to ASP.NET Core	Add feature flags to ASP.NET Core apps and manage them using Azure App Configuration	maud-lv	azure-app-configuration	csharp	devx-track-csharp, mode-other	quickstart	09/28/2020	malev

Quickstart: Add feature flags to an ASP.NET Core app

In this quickstart, you create an end-to-end implementation of feature management in an ASP.NET Core app using Azure App Configuration. You'll use the App Configuration service to centrally store all your feature flags and control their states.

The .NET Core Feature Management libraries extend the framework with comprehensive feature flag support. These libraries are built on top of the .NET Core configuration system. They seamlessly integrate with App Configuration through its .NET Core configuration provider.

Prerequisites

• Azure subscription - create one for free
• .NET Core SDK

Create an App Configuration store

[!INCLUDEAzure App Configuration resource creation steps]

8. Select Operations > Feature manager > Add to add a feature flag called Beta.

   [!div class="mx-imgBorder"]

   Leave Label empty for now. Select Apply to save the new feature flag.

Create an ASP.NET Core web app

Use the .NET Core command-line interface (CLI) to create a new ASP.NET Core MVC project. The advantage of using the .NET Core CLI instead of Visual Studio is that the .NET Core CLI is available across the Windows, macOS, and Linux platforms.

Run the following command to create an ASP.NET Core MVC project in a new TestFeatureFlags folder:

dotnet new mvc --no-https --output TestFeatureFlags

[!INCLUDEAdd Secret Manager support to an ASP.NET Core project]

Connect to an App Configuration store

1. Install the Microsoft.Azure.AppConfiguration.AspNetCore and Microsoft.FeatureManagement.AspNetCore NuGet packages by running the following commands:

   dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
   

   dotnet add package Microsoft.FeatureManagement.AspNetCore
   

2. Run the following command in the same directory as the .csproj file. The command uses Secret Manager to store a secret named ConnectionStrings:AppConfig, which stores the connection string for your App Configuration store. Replace the <your_connection_string> placeholder with your App Configuration store's connection string. You can find the connection string under Access Keys in the Azure portal.

   dotnet user-secrets set ConnectionStrings:AppConfig "<your_connection_string>"
   

   Secret Manager is used only to test the web app locally. When the app is deployed to Azure App Service, use the Connection Strings application setting in App Service instead of Secret Manager to store the connection string.

   Access this secret using the .NET Core Configuration API. A colon (:) works in the configuration name with the Configuration API on all supported platforms. For more information, see Configuration keys and values.

3. In Program.cs, update the CreateWebHostBuilder method to use App Configuration by calling the AddAzureAppConfiguration method.

   [!IMPORTANT] CreateHostBuilder replaces CreateWebHostBuilder in .NET Core 3.x. Select the correct syntax based on your environment.

   .NET 5.x

   public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureWebHostDefaults(webBuilder =>
               webBuilder.ConfigureAppConfiguration(config =>
               {
                   var settings = config.Build();
                   var connection = settings.GetConnectionString("AppConfig");
                   config.AddAzureAppConfiguration(options =>
                       options.Connect(connection).UseFeatureFlags());
               }).UseStartup<Startup>());

   .NET Core 3.x

   public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureWebHostDefaults(webBuilder =>
               webBuilder.ConfigureAppConfiguration(config =>
               {
                   var settings = config.Build();
                   var connection = settings.GetConnectionString("AppConfig");
                   config.AddAzureAppConfiguration(options =>
                       options.Connect(connection).UseFeatureFlags());
               }).UseStartup<Startup>());

   .NET Core 2.x

   public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
       WebHost.CreateDefaultBuilder(args)
              .ConfigureAppConfiguration(config =>
              {
                  var settings = config.Build();
                  var connection = settings.GetConnectionString("AppConfig");
                  config.AddAzureAppConfiguration(options =>
                      options.Connect(connection).UseFeatureFlags());
              }).UseStartup<Startup>();

   ---

   With the preceding change, the configuration provider for App Configuration has been registered with the .NET Core Configuration API.

4. In Startup.cs, add a reference to the .NET Core feature manager:

   using Microsoft.FeatureManagement;

5. Update the Startup.ConfigureServices method to add feature flag support by calling the AddFeatureManagement method. Optionally, you can include any filter to be used with feature flags by calling AddFeatureFilter<FilterType>():

   .NET 5.x

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddControllersWithViews();
       services.AddFeatureManagement();
   }

   .NET Core 3.x

   Add the following code:

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddControllersWithViews();
       services.AddAzureAppConfiguration();
       services.AddFeatureManagement();
   }

   And then add below:

   public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
   {
       // ...
       app.UseAzureAppConfiguration();
   }

   .NET Core 2.x

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddMvc()
           .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
       services.AddFeatureManagement();
   }

   ---

6. Add a MyFeatureFlags.cs file to the root project directory with the following code:

   namespace TestFeatureFlags
   {
       public enum MyFeatureFlags
       {
           Beta
       }
   }

7. Add a BetaController.cs file to the Controllers directory with the following code:

   using Microsoft.AspNetCore.Mvc;
   using Microsoft.FeatureManagement;
   using Microsoft.FeatureManagement.Mvc;
   
   namespace TestFeatureFlags.Controllers
   {
       public class BetaController: Controller
       {
           private readonly IFeatureManager _featureManager;
   
           public BetaController(IFeatureManagerSnapshot featureManager) =>
               _featureManager = featureManager;
   
           [FeatureGate(MyFeatureFlags.Beta)]
           public IActionResult Index() => View();
       }
   }

8. In Views/_ViewImports.cshtml, register the feature manager Tag Helper using an @addTagHelper directive:

   @addTagHelper *, Microsoft.FeatureManagement.AspNetCore

   The preceding code allows the <feature> Tag Helper to be used in the project's .cshtml files.

9. Open _Layout.cshtml in the Views\Shared directory. Locate the <nav> bar code under <body> > <header>. Insert a new <feature> tag in between the Home and Privacy navbar items, as shown in the highlighted lines below.

   :::code language="html" source="../../includes/azure-app-configuration-navbar.md" range="15-38" highlight="14-18":::

10. Create a Views/Beta directory and an Index.cshtml file containing the following markup:

    @{
        ViewData["Title"] = "Beta Home Page";
    }
    
    <h1>This is the beta website.</h1>

Build and run the app locally

1. To build the app by using the .NET Core CLI, run the following command in the command shell:

   dotnet build
   

2. After the build successfully completes, run the following command to run the web app locally:

   dotnet run
   

3. Open a browser window, and go to http://localhost:5000, which is the default URL for the web app hosted locally. If you're working in the Azure Cloud Shell, select the Web Preview button followed by Configure. When prompted, select port 5000.

   

   Your browser should display a page similar to the image below.

   :::image type="content" source="media/quickstarts/aspnet-core-feature-flag-local-before.png" alt-text="Local quickstart app before change" border="true":::

4. Sign in to the Azure portal. Select All resources, and select the App Configuration store instance that you created in the quickstart.

5. Select Feature manager.

6. Enable the Beta flag by selecting the checkbox under Enabled.

7. Return to the command shell. Cancel the running dotnet process by pressing Ctrl+C. Restart your app using dotnet run.

8. Refresh the browser page to see the new configuration settings.

   :::image type="content" source="media/quickstarts/aspnet-core-feature-flag-local-after.png" alt-text="Local quickstart app after change" border="true":::

Clean up resources

[!INCLUDEAzure App Configuration cleanup]

Next steps

In this quickstart, you created a new App Configuration store and used it to manage features in an ASP.NET Core web app via the Feature Management libraries.

• Learn more about feature management.
• Manage feature flags.
• Use feature flags in an ASP.NET Core app.
• Use dynamic configuration in an ASP.NET Core app