Skip to content
Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


Build status

Provides ASP.NET Core support for NFig by integrating into the options framework.

Package Status

MyGet Pre-release feed:

Package NuGet Stable NuGet Pre-release Downloads MyGet
NFig.AspNetCore NFig.AspNetCore NFig.AspNetCore NFig.AspNetCore NFig.AspNetCore MyGet

Getting Started

Integrating NFig into your ASP.NET Core application is easy!


Install the [NFig.AspNetCore]( NuGet package using:

dotnet add <project> package NFig.AspNetCore

If setting up a web project it's a good idea to check out the sample project.


NFig can be configured by using the code below. You can see we have defined a Settings class containing the settings our application needs, a Tier enum representing the different tiers our application can run in and a DataCenter enum representing the data centers that our application runs in.

We add a call to AddNFig in our ConfigureServices method specifying the types above so NFig knows how to manage our settings. Under the hood this tells the DI container how to resolve an IOptions<Settings> and also IOptions<T> where T is any setting group specified within our settings (e.g. FeatureFlagSettings).

Next we call UseNFig in our Configure method. This is passed a builder that can be used to configure NFig's backing store. Right now NFig only has Redis as a backing store so we simply configure Redis using a connection string from our configuration file. Our configuration file also tells us what tier and data center our application is running in, so we pass those to NFig as well.

That's it!


    "ApplicationName": "NFig Example",
    "Tier": "Local",
    "DataCenter": "Local",
    "ConnectionStrings": {
        "Redis": "localhost:6379,defaultDatabase=0"


public class Settings
    public FeatureFlagSettings FeatureFlags { get; private set; }

    public class FeatureFlagSettings
        [Description("Enables the [Whizzbang]( feature.")]
        [TieredDefaultValue(Tier.Local, true)]
        [TieredDefaultValue(Tier.Dev, true)]
        public bool EnableWhizzbang { get; private set; }

public enum Tier

public enum DataCenter

public class AppSettings
    public string ApplicationName { get; set; }
    public Tier Tier { get; set; }
    public DataCenter { get; set; }

public class Startup
    private readonly IConfiguration _configuration;

    public Startup(IConfiguration configuration)
        _configuration = configuration;

    public void ConfigureServices(IServiceCollection services)
        // add services needed by NFig
        // under the hood this configures the DI container
        // to resolve NFig settings as IOptions implementations
        services.AddNFig<Settings, Tier, DataCenter>();

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        // configure NFig's backing store
            .UseNFig<Settings, Tier, DataCenter>(
                (cfg, builder) =>
                    var settings = cfg.Get<AppSettings>();
                    var connectionString = cfg.GetConnectionString("Redis");

                    // connects NFig to Redis
                    builder.UseRedis(settings.ApplicationName, settings.Tier, settings.DataCenter, connectionString);

Exposing NFig UI

NFig.AspNetCore contains middleware that can render NFig.UI. It can be called from within MVC or by a route handler in Kestrel. This way you can lock down the route using your current security models.

Using MVC

public class SettingsController
    // restrict this route to users in the Admins role
    [Authorize(Roles = "Admins")]
    public Task Settings() => NFigMiddleware<Settings, Tier, DataCenter>.HandleRequestAsync(HttpContext);

Using Kestrel

public class Startup
    // ... other startup bits here

    public void Configure(IAppBuilder app, IHostingEnvironment env)
            ctx => ctx.Request.Path.StartsWithSegments("/settings"),
            appBuilder => appBuilder.Run(NFigMiddleware<Settings, Tier, DataCenter>.HandleRequestAsync)

Using Our Settings

To use our settings all we have to do is inject them wherever we need to use them.

In an MVC Controller

public class HomeController : Controller
    private readonly FeatureFlagSettings _featureFlags;

    public HomeController(IOptions<FeatureFlagSettings> featureFlags)
        _featureFlags = featureFlags.Value;

    public IActionResult Home()
        if (_featureFlags.EnableWhizzbang)
            return Content("Whizzbang enabled!");

        return Content("Whizzbang disabled");

In an MVC View

@model MyModel
@inject IOptions<FeatureFlagSettings> featureFlags

@if (featureFlags.Value.EnableWhizzbangFeature)
    <strong>Whizzbang enabled</strong>
    <strong>Whizzbang disabled</strong>


  • support NFig 3.x
  • some tests would be nice


Integrates NFig with ASP.NET Core via the options pattern




No releases published


No packages published