Indiko.Blocks.API.FeatureManagement 2.1.2

Indiko.Blocks.API.FeatureManagement

Feature flag management block for controlling feature rollouts, A/B testing, and gradual deployments using Microsoft Feature Management.

Overview

This package provides feature flag (feature toggle) support for ASP.NET Core APIs, enabling dynamic feature control without code deployments.

Features

• Feature Flags: Enable/disable features dynamically
• Conditional Features: Context-based feature activation
• A/B Testing: Percentage-based feature rollouts
• Targeting: User/group-specific features
• Time Windows: Schedule feature availability
• MVC Integration: Feature-aware controllers and actions
• IFeatureManager: Programmatic feature checks
• Configuration-Based: Define features in appsettings.json

Installation

dotnet add package Indiko.Blocks.API.FeatureManagement

Quick Start

Configuration (appsettings.json)

{
  "FeatureManagement": {
    "NewUserInterface": true,
    "BetaFeatures": false,
    "PremiumFeatures": {
      "EnabledFor": [
        {
          "Name": "Percentage",
          "Parameters": {
            "Value": 50
          }
        }
      ]
    }
  }
}

Basic Usage

Check Features in Code

using Microsoft.FeatureManagement;

public class ProductsController : ControllerBase
{
    private readonly IFeatureManager _featureManager;

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

    [HttpGet]
    public async Task<IActionResult> GetProducts()
    {
        if (await _featureManager.IsEnabledAsync("NewUserInterface"))
        {
            return Ok(await GetProductsWithNewUI());
        }
        
        return Ok(await GetProductsWithOldUI());
    }
}

Feature Gates on Actions

using Microsoft.FeatureManagement.Mvc;

[ApiController]
[Route("api/[controller]")]
public class BetaController : ControllerBase
{
    [HttpGet]
    [FeatureGate("BetaFeatures")]  // Only accessible if BetaFeatures is enabled
    public IActionResult GetBetaFeature()
    {
        return Ok("Beta feature data");
    }
}

Feature Types

Simple Boolean Flags

{
  "FeatureManagement": {
    "DarkMode": true,
    "MaintenanceMode": false
  }
}

if (await _featureManager.IsEnabledAsync("DarkMode"))
{
    // Apply dark mode
}

Percentage Rollout (A/B Testing)

{
  "FeatureManagement": {
    "NewCheckout": {
      "EnabledFor": [
        {
          "Name": "Percentage",
          "Parameters": {
            "Value": 25  // 25% of users see new checkout
          }
        }
      ]
    }
  }
}

Time Window Features

{
  "FeatureManagement": {
    "HolidaySale": {
      "EnabledFor": [
        {
          "Name": "TimeWindow",
          "Parameters": {
            "Start": "2024-12-20T00:00:00Z",
            "End": "2024-12-26T23:59:59Z"
          }
        }
      ]
    }
  }
}

User Targeting

{
  "FeatureManagement": {
    "PremiumFeatures": {
      "EnabledFor": [
        {
          "Name": "TargetingFilter",
          "Parameters": {
            "Audience": {
              "Users": [
                "user1@example.com",
                "user2@example.com"
              ],
              "Groups": [
                "premium",
                "beta-testers"
              ]
            }
          }
        }
      ]
    }
  }
}

Feature Filters

Built-in Filters

1. Percentage Filter: Gradual rollout based on percentage
2. Time Window Filter: Time-based activation
3. Targeting Filter: User/group-based activation

Custom Feature Filter

using Microsoft.FeatureManagement;

[FilterAlias("Environment")]
public class EnvironmentFeatureFilter : IFeatureFilter
{
    private readonly IWebHostEnvironment _environment;

    public EnvironmentFeatureFilter(IWebHostEnvironment environment)
    {
        _environment = environment;
    }

    public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
    {
        var settings = context.Parameters.Get<EnvironmentFilterSettings>();
        return Task.FromResult(settings.Environments.Contains(_environment.EnvironmentName));
    }
}

public class EnvironmentFilterSettings
{
    public string[] Environments { get; set; }
}

// Register
services.AddFeatureManagement()
    .AddFeatureFilter<EnvironmentFeatureFilter>();

// Use in config
{
  "FeatureManagement": {
    "DebugTools": {
      "EnabledFor": [
        {
          "Name": "Environment",
          "Parameters": {
            "Environments": ["Development", "Staging"]
          }
        }
      ]
    }
  }
}

Controller-Level Gates

[ApiController]
[Route("api/[controller]")]
[FeatureGate("AdminPanel")]  // Entire controller requires feature
public class AdminController : ControllerBase
{
    [HttpGet("users")]
    public IActionResult GetUsers() => Ok(users);
    
    [HttpGet("settings")]
    [FeatureGate("AdvancedSettings")]  // Additional feature requirement
    public IActionResult GetSettings() => Ok(settings);
}

Middleware Integration

public class FeatureCheckMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IFeatureManager _featureManager;

    public FeatureCheckMiddleware(RequestDelegate next, IFeatureManager featureManager)
    {
        _next = next;
        _featureManager = featureManager;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path.StartsWithSegments("/api/beta"))
        {
            if (!await _featureManager.IsEnabledAsync("BetaAccess"))
            {
                context.Response.StatusCode = 403;
                await context.Response.WriteAsync("Beta access not available");
                return;
            }
        }
        
        await _next(context);
    }
}

Service Layer

public class ProductService
{
    private readonly IFeatureManager _featureManager;
    private readonly IProductRepository _repository;

    public async Task<ProductDto> GetProductAsync(Guid id)
    {
        var product = await _repository.ReadByIdAsync(id);
        
        if (await _featureManager.IsEnabledAsync("EnhancedProductDetails"))
        {
            product.AdditionalDetails = await LoadEnhancedDetails(id);
        }
        
        return product;
    }
}

Configuration Sources

AppSettings

{
  "FeatureManagement": {
    "Feature1": true
  }
}

Environment Variables

export FeatureManagement__Feature1=true

Azure App Configuration

services.AddAzureAppConfiguration(options =>
{
    options.Connect(connectionString)
           .UseFeatureFlags();
});

Best Practices

1. Naming: Use descriptive names (NewCheckoutFlow, EnhancedSearch)
2. Cleanup: Remove feature flags once fully rolled out
3. Testing: Test both enabled and disabled states
4. Documentation: Document what each feature flag controls
5. Monitoring: Track feature usage and performance
6. Gradual Rollout: Start with small percentages
7. Fallbacks: Always have fallback logic

Deployment Strategies

Canary Deployment

{
  "FeatureManagement": {
    "NewPaymentGateway": {
      "EnabledFor": [
        {
          "Name": "Percentage",
          "Parameters": { "Value": 5 }  // Start with 5%
        }
      ]
    }
  }
}

Monitor, then increase: 5% ? 25% ? 50% ? 100%

Blue-Green Deployment

{
  "FeatureManagement": {
    "UseNewDatabase": false  // Toggle between old/new
  }
}

Testing

Unit Testing

[Fact]
public async Task GetProducts_WithNewUI_ReturnsEnhancedData()
{
    // Arrange
    var featureManagerMock = new Mock<IFeatureManager>();
    featureManagerMock
        .Setup(x => x.IsEnabledAsync("NewUserInterface", It.IsAny<CancellationToken>()))
        .ReturnsAsync(true);
    
    var controller = new ProductsController(featureManagerMock.Object);
    
    // Act
    var result = await controller.GetProducts();
    
    // Assert
    Assert.IsType<OkObjectResult>(result);
}

Target Framework

• .NET 10

Dependencies

• Microsoft.FeatureManagement.AspNetCore (3.0+)
• Indiko.Blocks.Common.Abstractions

License

See LICENSE file in the repository root.

Related Packages

• Indiko.Blocks.API.Swagger - API documentation
• Indiko.Blocks.API.Compression - Response compression
• Microsoft.FeatureManagement - Core feature management
• Microsoft.FeatureManagement.AspNetCore - ASP.NET Core integration

Resources

• Microsoft Feature Management Documentation