ASP.NET Core middleware for POST Tunneling support

PostTunnelingMiddleware.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;

namespace Demo.AspNetCore.PostTunneling.Middlewares
{
    public class PostTunnelingMiddleware
    {
        private readonly RequestDelegate _next;

        private readonly string _headerName;
        private readonly HashSet<string> _allowedMethods;

        public PostTunnelingMiddleware(RequestDelegate next, IOptions<PostTunnelingOptions> options)
        {
            _next = next ?? throw new ArgumentNullException(nameof(next));

            if (options?.Value == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            _headerName = options.Value.HeaderName;
            _allowedMethods = new HashSet<string>();

            if (options.Value.AllowedMethods != null)
            {
                foreach (string allowedMethod in options.Value.AllowedMethods)
                {
                    _allowedMethods.Add(allowedMethod.ToUpper());
                }
            }
        }
        
        public Task Invoke(HttpContext context)
        {
            if (HttpMethods.IsPost(context.Request.Method))
            {
                if (context.Request.Headers.ContainsKey(_headerName))
                {
                    string tunelledMethod = context.Request.Headers[_headerName];
                    if (_allowedMethods.Contains(tunelledMethod))
                    {
                        IHttpRequestFeature httpRequestFeature = context.Features.Get<IHttpRequestFeature>();
                        httpRequestFeature.Method = tunelledMethod;
                    }
                }
            }

            return _next(context);
        }
    }
}

PostTunnelingMiddlewareExtensions.cs

using System;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Builder;

namespace Demo.AspNetCore.PostTunneling.Middlewares
{
    public static class PostTunnelingMiddlewareExtensions
    {
        public static IApplicationBuilder UsePostTunneling(this IApplicationBuilder app)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

            return app.UseMiddleware<PostTunnelingMiddleware>();
        }

        public static IApplicationBuilder UsePostTunneling(this IApplicationBuilder app, PostTunnelingOptions options)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            return app.UseMiddleware<PostTunnelingMiddleware>(Options.Create(options));
        }
    }
}

PostTunnelingOptions.cs

using System.Collections.Generic;

namespace Demo.AspNetCore.PostTunneling.Middlewares
{
    public class PostTunnelingOptions
    {
        public string HeaderName { get; set; }

        public IEnumerable<string> AllowedMethods { get; set; }
    }
}

Description --> https://www.tpeczek.com/2017/12/post-tunneling-middleware-for-aspnet.html