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

[Get("/api/planets")]
Task<StarwarsPlanets> GetPlanets();

public class StarwarsController : Controller
{
    private readonly IFeatureManager featureManager;

    public StarwarsController(ISwapiClient proxy, IFeatureManager featureManager)
    {
        this.proxy = proxy;
        this.featureManager = featureManager;
    }

    //optional if you want to lock on the controller
    //[FeatureGate(FeatureToggles.ShowPlanetsOfStarwars)]
    public async Task<IActionResult> Planets()
    {
        return View(await proxy.GetPlanets().ConfigureAwait(true));
    }

using Refit;
using System.Threading.Tasks;

namespace StarwarsWeb.HardProviders
{
    public interface IStarshipClient
    {
        Task<Starships> GetStarships();
    }
}

services.AddTransient<IStarshipClient,HardStarshipProvider>();

private readonly ISwapiClient proxy;
private readonly IStarshipClient starshipProxy;

public StarwarsController(ISwapiClient proxy, IStarshipClient starshipProxy)
{
    this.proxy = proxy;
    this.starshipProxy = starshipProxy;
}

    public enum FeatureToggles
    {
        ShowPlanetsOfStarwars,
        UseImprovedStarshipProvider
    }

public StarwarsController(ISwapiClient proxy, Func<bool, IStarshipClient> starshipProxy, IFeatureManager featureManager)
{
    this.proxy = proxy;
    this.starshipProxy = starshipProxy(featureManager.IsEnabled(nameof(FeatureToggles.UseImprovedStarshipProvider)));
}

public interface IStarshipClient
{
    [Get("/api/starships")]
    Task<Starships> GetStarships();
}

services.AddHttpClient("StarshipAPIs", options =>
{
    options.BaseAddress = new Uri(Configuration["SwapiApiOptions:BaseUrl"]);
    options.Timeout = TimeSpan.FromMilliseconds(15000);
    options.DefaultRequestHeaders.Add("ClientFactory", "Check");
})
.AddPolicyHandler(Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromMilliseconds(15000)))
.AddTransientHttpErrorPolicy(p => p.RetryAsync(3))
.AddTypedClient(client => RestService.For<IStarshipClient>(client));

services.AddTransient<HardStarshipProvider>();
services.AddTransient<Func<bool, IStarshipClient>>(serviceProvider => UseImprovedStarshipProvider =>
{
    switch (UseImprovedStarshipProvider)
    {
        case true:
            return serviceProvider.GetService<IStarshipClient>();

        default:
            return serviceProvider.GetService<HardStarshipProvider>();
    }
});

        public void ConfigureServices(IServiceCollection services)
        {
            ConfigureTypedClients(services);
            services.AddFeatureManagement().AddFeatureFilter<PercentageFilter>();
            services.AddControllersWithViews();
        }

app.UseRouting();

//Add azure app configuraiton
app.UseAzureAppConfiguration();

app.UseAuthorization();

using Microsoft.Extensions.Configuration.AzureAppConfiguration;

//[....]

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.ConfigureAppConfiguration((hostingContext, config) =>
                {
                    var aspnetcorEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
                    if (string.IsNullOrEmpty(aspnetcorEnvironment) || !aspnetcorEnvironment.Equals("Development", StringComparison.OrdinalIgnoreCase))
                    {
                        var settings = config.Build();

                        config.AddAzureAppConfiguration(options =>
                        {
                            options.Connect(settings["ConnectionStrings:AppConfig"])
                            .UseFeatureFlags();
                        });
                    }
                });
                webBuilder.UseStartup<Startup>();
            });