Added dependency injection/easy registration for async filters

src/Swashbuckle.AspNetCore.SwaggerGen/DependencyInjection/ConfigureSwaggerGeneratorOptions.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Microsoft.OpenApi.Models;
@@ -46,6 +47,19 @@ public void Configure(SwaggerGeneratorOptions options)
             _swaggerGenOptions.DocumentFilterDescriptors.ForEach(
                 filterDescriptor => options.DocumentFilters.Add(GetOrCreateFilter<IDocumentFilter>(filterDescriptor)));
 
+
+            _swaggerGenOptions.ParameterAsyncFilterDescriptors.ForEach(
+                filterDescriptor => options.ParameterAsyncFilters.Add(GetOrCreateFilter<IParameterAsyncFilter>(filterDescriptor)));
+
+            _swaggerGenOptions.RequestBodyAsyncFilterDescriptors.ForEach(
+                filterDescriptor => options.RequestBodyAsyncFilters.Add(GetOrCreateFilter<IRequestBodyAsyncFilter>(filterDescriptor)));
+
+            _swaggerGenOptions.OperationAsyncFilterDescriptors.ForEach(
+                filterDescriptor => options.OperationAsyncFilters.Add(GetOrCreateFilter<IOperationAsyncFilter>(filterDescriptor)));
+
+            _swaggerGenOptions.DocumentAsyncFilterDescriptors.ForEach(
+                filterDescriptor => options.DocumentAsyncFilters.Add(GetOrCreateFilter<IDocumentAsyncFilter>(filterDescriptor)));
+
             if (!options.SwaggerDocs.Any())
             {
                 options.SwaggerDocs.Add("v1", new OpenApiInfo { Title = _hostingEnv.ApplicationName, Version = "1.0" });

src/Swashbuckle.AspNetCore.SwaggerGen/DependencyInjection/SwaggerGenOptions.cs

@@ -23,6 +23,14 @@ public class SwaggerGenOptions
         public List<FilterDescriptor> DocumentFilterDescriptors { get; set; } = new List<FilterDescriptor>();
 
         public List<FilterDescriptor> SchemaFilterDescriptors { get; set; } = new List<FilterDescriptor>();
+
+        public List<FilterDescriptor> ParameterAsyncFilterDescriptors { get; set; } = new List<FilterDescriptor>();
+
+        public List<FilterDescriptor> RequestBodyAsyncFilterDescriptors { get; set; } = new List<FilterDescriptor>();
+
+        public List<FilterDescriptor> OperationAsyncFilterDescriptors { get; set; } = new List<FilterDescriptor>();
+
+        public List<FilterDescriptor> DocumentAsyncFilterDescriptors { get; set; } = new List<FilterDescriptor>();
     }
 
     public class FilterDescriptor

src/Swashbuckle.AspNetCore.SwaggerGen/DependencyInjection/SwaggerGenOptionsExtensions.cs

@@ -353,7 +353,7 @@ public static void SchemaFilter<TFilter>(
                 Type = typeof(TFilter),
                 Arguments = arguments
             });
-        }
+        } 
 
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify Schemas after they're initially generated
@@ -393,6 +393,25 @@ public static void ParameterFilter<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify Parameters asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IParameterAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="arguments">Optionally inject parameters through filter constructors</param>
+        public static void ParameterAsyncFilter<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            params object[] arguments)
+            where TFilter : IParameterAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            swaggerGenOptions.ParameterAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                Type = typeof(TFilter),
+                Arguments = arguments
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify Parameters after they're initially generated
         /// </summary>
@@ -412,6 +431,25 @@ public static void AddParameterFilterInstance<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify Parameters asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IParameterAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="filterInstance">The filter instance to use.</param>
+        public static void AddParameterAsyncFilterInstance<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            TFilter filterInstance)
+            where TFilter : IParameterAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            if (filterInstance == null) throw new ArgumentNullException(nameof(filterInstance));
+            swaggerGenOptions.ParameterAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                FilterInstance = filterInstance
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify RequestBodys after they're initially generated
         /// </summary>
@@ -431,6 +469,25 @@ public static void RequestBodyFilter<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify RequestBodys asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IRequestBodyAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="arguments">Optionally inject parameters through filter constructors</param>
+        public static void RequestBodyAsyncFilter<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            params object[] arguments)
+            where TFilter : IRequestBodyAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            swaggerGenOptions.RequestBodyAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                Type = typeof(TFilter),
+                Arguments = arguments
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify RequestBodys after they're initially generated
         /// </summary>
@@ -450,6 +507,25 @@ public static void AddRequestBodyFilterInstance<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify RequestBodys asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IRequestBodyAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="filterInstance">The filter instance to use.</param>
+        public static void AddRequestBodyAsyncFilterInstance<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            TFilter filterInstance)
+            where TFilter : IRequestBodyAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            if (filterInstance == null) throw new ArgumentNullException(nameof(filterInstance));
+            swaggerGenOptions.RequestBodyAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                FilterInstance = filterInstance
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify Operations after they're initially generated
         /// </summary>
@@ -469,6 +545,25 @@ public static void OperationFilter<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify Operations asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IOperationAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="arguments">Optionally inject parameters through filter constructors</param>
+        public static void OperationAsyncFilter<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            params object[] arguments)
+            where TFilter : IOperationAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            swaggerGenOptions.OperationAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                Type = typeof(TFilter),
+                Arguments = arguments
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify Operations after they're initially generated
         /// </summary>
@@ -488,6 +583,25 @@ public static void AddOperationFilterInstance<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify Operations asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IOperationAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="filterInstance">The filter instance to use</param>
+        public static void AddOperationAsyncFilterInstance<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            TFilter filterInstance)
+            where TFilter : IOperationAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            if (filterInstance == null) throw new ArgumentNullException(nameof(filterInstance));
+            swaggerGenOptions.OperationAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                FilterInstance = filterInstance
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify SwaggerDocuments after they're initially generated
         /// </summary>
@@ -507,6 +621,26 @@ public static void DocumentFilter<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify SwaggerDocuments asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IDocumentAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="arguments">Optionally inject parameters through filter constructors</param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public static void DocumentAsyncFilter<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            params object[] arguments)
+            where TFilter : IDocumentAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            swaggerGenOptions.DocumentAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                Type = typeof(TFilter),
+                Arguments = arguments
+            });
+        }
+
         /// <summary>
         /// Extend the Swagger Generator with "filters" that can modify SwaggerDocuments after they're initially generated
         /// </summary>
@@ -526,6 +660,26 @@ public static void AddDocumentFilterInstance<TFilter>(
             });
         }
 
+        /// <summary>
+        /// Extend the Swagger Generator with "filters" that can modify SwaggerDocuments asynchronously after they're initially generated
+        /// </summary>
+        /// <typeparam name="TFilter">A type that derives from <see cref="IDocumentAsyncFilter"/></typeparam>
+        /// <param name="swaggerGenOptions"></param>
+        /// <param name="filterInstance">The filter instance to use.</param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public static void AddDocumentAsyncFilterInstance<TFilter>(
+            this SwaggerGenOptions swaggerGenOptions,
+            TFilter filterInstance)
+            where TFilter : IDocumentAsyncFilter
+        {
+            if (swaggerGenOptions == null) throw new ArgumentNullException(nameof(swaggerGenOptions));
+            if (filterInstance == null) throw new ArgumentNullException(nameof(filterInstance));
+            swaggerGenOptions.DocumentAsyncFilterDescriptors.Add(new FilterDescriptor
+            {
+                FilterInstance = filterInstance
+            });
+        }
+
         /// <summary>
         /// Inject human-friendly descriptions for Operations, Parameters and Schemas based on XML Comment files
         /// </summary>

src/Swashbuckle.AspNetCore.SwaggerGen/PublicAPI/PublicAPI.Unshipped.txt

@@ -0,0 +1,16 @@
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.AddDocumentAsyncFilterInstance<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, TFilter filterInstance) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.AddOperationAsyncFilterInstance<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, TFilter filterInstance) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.AddParameterAsyncFilterInstance<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, TFilter filterInstance) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.AddRequestBodyAsyncFilterInstance<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, TFilter filterInstance) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.DocumentAsyncFilter<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, params object[] arguments) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.OperationAsyncFilter<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, params object[] arguments) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.ParameterAsyncFilter<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, params object[] arguments) -> void
+static Microsoft.Extensions.DependencyInjection.SwaggerGenOptionsExtensions.RequestBodyAsyncFilter<TFilter>(this Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions swaggerGenOptions, params object[] arguments) -> void
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.DocumentAsyncFilterDescriptors.get -> System.Collections.Generic.List<Swashbuckle.AspNetCore.SwaggerGen.FilterDescriptor>
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.DocumentAsyncFilterDescriptors.set -> void
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.OperationAsyncFilterDescriptors.get -> System.Collections.Generic.List<Swashbuckle.AspNetCore.SwaggerGen.FilterDescriptor>
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.OperationAsyncFilterDescriptors.set -> void
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.ParameterAsyncFilterDescriptors.get -> System.Collections.Generic.List<Swashbuckle.AspNetCore.SwaggerGen.FilterDescriptor>
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.ParameterAsyncFilterDescriptors.set -> void
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.RequestBodyAsyncFilterDescriptors.get -> System.Collections.Generic.List<Swashbuckle.AspNetCore.SwaggerGen.FilterDescriptor>
+Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions.RequestBodyAsyncFilterDescriptors.set -> void