How can I exclude a controller from ASP.NET Core 3 Attribute Routing

You can implement your own ControllerFeatureProvider and decide which controllers you want to have in your application.

public class CustomControllerFeatureProvider : ControllerFeatureProvider
{
    private readonly IConfiguration _configuration;

    public CustomControllerFeatureProvider(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    protected override bool IsController(TypeInfo typeInfo)
    {
        var isController = base.IsController(typeInfo);

        if (isController)
        {
            var enabledController = _configuration.GetValue<string[]>("EnabledController");

            isController = enabledController.Any(x => typeInfo.Name.Equals(x, StringComparison.InvariantCultureIgnoreCase));
        }

        return isController;
    }
}

And add it in startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
        .ConfigureApplicationPartManager(manager =>
        {
            manager.FeatureProviders.Remove(manager.FeatureProviders.OfType<ControllerFeatureProvider>().FirstOrDefault());
            manager.FeatureProviders.Add(new CustomControllerFeatureProvider(_configuration));
        });
}

If you are use the FeatureManagement of the answer of Nathan Daniels. You can use this DocumentFilter to hide the controller in Swashbucke.

services.AddSwaggerGen(c =>
{
    c.DocumentFilter<FeatureGateDocumentFilter>();
});

FeatureGateDocumentFilter.cs

using Microsoft.FeatureManagement;
using Microsoft.FeatureManagement.Mvc;
using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.SwaggerGen;
using System.Linq;

namespace Portalum.Sales.WebShopApi.OperationFilters
{
    public class FeatureGateDocumentFilter : IDocumentFilter
    {
        private readonly IFeatureManager _featureManager;

        public FeatureGateDocumentFilter(IFeatureManager featureManager)
        {
            this._featureManager = featureManager;
        }

        public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
        {      
            foreach (var apiDescription in context.ApiDescriptions)
            {
                var filterPipeline = apiDescription.ActionDescriptor.FilterDescriptors;
                var filterMetaData = filterPipeline.Select(filterInfo => filterInfo.Filter).SingleOrDefault(filter => filter is FeatureGateAttribute);
                if (filterMetaData == default)
                {
                    continue;
                }

                var featureGateAttribute = filterMetaData as FeatureGateAttribute;
                var isActive = this._featureManager.IsEnabledAsync(featureGateAttribute.Features.Single()).GetAwaiter().GetResult();
                if (isActive)
                {
                    continue;
                }

                var apiPath = swaggerDoc.Paths.FirstOrDefault(o => o.Key.Contains(apiDescription.RelativePath));
                swaggerDoc.Paths.Remove(apiPath.Key);
            }
        }
    }
}

Alternatively, you could use one of the filters in ASP.NET Core to do this with more flexibility and readability.

And importantly, controllers behind feature toggles are still a valid controllers in your application. That, if you want to test those controllers with your special test purpose requests, you can still do it.

You could apply filter to either controller level or action level to either feature toggle all actions in controller, or a single action in controller.

Here is an example done using ActionFilterAttribute:

public class ToggledAttribute : ActionFilterAttribute
{
    // Can reuse the attribute for different controllers / actions
    // based on different configuration
    public ToggledAttribute(string configurationName = null)
    {
        ConfigurationName = configurationName;
    }

    public string ConfigurationName { get; }

    public override void OnActionExecuting(ActionExecutingContext context)
    {
        var isTestRequest =
            context.HttpContext.Request.Headers["x-my-test-header"].Count > 0;

        if (isTestRequest)
        {
            return;
        }

        var configuration = (IConfiguration)context.HttpContext.RequestServices
            .GetService(typeof(IConfiguration));

        // Somehow read toggle from configuration
        var featureEnabled = ...

        if (!featureEnabled)
        {
            context.Result = new NotFoundResult();
        }
    }
}

Apply to your controllers or actions where toggling needed:

[Route("[controller]")]
[Toggled]
public class MyToggledController : ControllerBase
{
    // OR
    [Toggled]
    [HttpGet]
    public int Get()
    {
        return 1;
    }
}

The example from @live2 is nice; just needs some modifications so it copes with multiple feature flags on the same controller:

    /// <summary>
    /// Swagger filter which allows [FeatureGate] attribute to be used to filter out 
    /// controllers and methods so feature flags take effect.
    /// </summary>
    public class FeatureGateDocumentFilter : IDocumentFilter
    {
        private readonly IFeatureManager _featureManager;

        /// <summary>
        /// Create new instance of filter.
        /// </summary>
        /// <param name="featureManager">Feature manager.</param>
        public FeatureGateDocumentFilter(IFeatureManager featureManager)
        {
            _featureManager = featureManager;
        }

        /// <inheritdoc />
        public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
        {
            foreach (var apiDescription in context.ApiDescriptions)
            {
                var filterPipeline = apiDescription.ActionDescriptor.FilterDescriptors;
                var featureAttributes = filterPipeline.Select(filterInfo => filterInfo.Filter).OfType<FeatureGateAttribute>().ToList();

                // Check the feature flags on all the [FeatureGate] attributes.
                bool allOk = true;
                foreach (var attribute in featureAttributes)
                {
                    var values = attribute.Features.Select(feature => _featureManager.IsEnabledAsync(feature).Result);
                    allOk &= (attribute.RequirementType == RequirementType.Any
                            ? values.Any(isEnabled => isEnabled)
                            : values.All(isEnabled => isEnabled)
                        );
                }

                if (!allOk)
                {
                    var apiPath = swaggerDoc.Paths.FirstOrDefault(o => o.Key.Contains(apiDescription.RelativePath!));
                    swaggerDoc.Paths.Remove(apiPath.Key);
                }
            }
        }
    }