Tweaking WCF to build highly scalable async REST API

namespace AsyncServiceLibrary
{
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Web;
    using System.Reflection;
    using System.ServiceModel;
    using System.Security;

    class MyHttpModule : IHttpModule
    {
        static BeginEventHandler beginEventHandler;
        static EndEventHandler endEventHandler;
        static MethodInfo safeEnsureInitialized;
        static MethodInfo getExtensionSupported;
        static ConstructorInfo hostedHttpRequestAsyncResult;
        static MethodInfo hostedHttpRequestAsyncResultEnd;
        static Type hostedHttpRequestAsyncResultType;

        static bool disabled;

        public void Dispose()
        {
        }

        public void Init(HttpApplication context)
        {
            if (MyHttpModule.safeEnsureInitialized == null)
            {
                safeEnsureInitialized = typeof(ServiceHostingEnvironment).GetMethod("SafeEnsureInitialized", BindingFlags.NonPublic | BindingFlags.Static);
            }

            if (MyHttpModule.getExtensionSupported == null)
            {
                getExtensionSupported = typeof(ServiceHostingEnvironment).GetMethod("GetExtensionSupported", BindingFlags.NonPublic | BindingFlags.Static);
            }

            if (hostedHttpRequestAsyncResultType == null)
            {
                hostedHttpRequestAsyncResultType = typeof(ServiceHostingEnvironment).Assembly.GetType("System.ServiceModel.Activation.HostedHttpRequestAsyncResult");
            }

            if (MyHttpModule.hostedHttpRequestAsyncResult == null)
            {
                hostedHttpRequestAsyncResult = hostedHttpRequestAsyncResultType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public,
                    null, new Type[] { typeof(HttpApplication), typeof(bool), typeof(AsyncCallback), typeof(object) }, null);
            }

            if (MyHttpModule.hostedHttpRequestAsyncResultEnd == null)
            {
                hostedHttpRequestAsyncResultEnd = hostedHttpRequestAsyncResultType.GetMethod("End", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Public);
            }

            if (MyHttpModule.beginEventHandler == null)
            {
                MyHttpModule.beginEventHandler = new BeginEventHandler(BeginProcessRequest);
            }

            if (MyHttpModule.endEventHandler == null)
            {
                MyHttpModule.endEventHandler = new EndEventHandler(EndProcessRequest);
            }

            context.AddOnPostAuthenticateRequestAsync(
                MyHttpModule.beginEventHandler,
                MyHttpModule.endEventHandler);
        }

        static public IAsyncResult BeginProcessRequest(object sender, EventArgs e, AsyncCallback cb, object extraData)
        {
            if (MyHttpModule.disabled)
            {
                return new CompletedHttpAsyncResult(cb, extraData); ;
            }

            try
            {
                safeEnsureInitialized.Invoke(null, null);
            }
            catch (SecurityException)
            {
                MyHttpModule.disabled = true;
                return new CompletedHttpAsyncResult(cb, extraData);
            }

            if (ServiceHostingEnvironment.AspNetCompatibilityEnabled)
            {
                return new CompletedHttpAsyncResult(cb, extraData);
            }

            // Check to see whether the extension is supported by WCF.
            HttpApplication application = (HttpApplication)sender;
            string extension = System.IO.Path.GetExtension(application.Request.FilePath);
            if (extension == null || !(bool)getExtensionSupported.Invoke(null, new object[] {extension}))
            {
                return new CompletedHttpAsyncResult(cb, extraData);
            }

            return (IAsyncResult)hostedHttpRequestAsyncResult.Invoke(new object[] { application, false, cb, extraData });
        }

        static public void EndProcessRequest(IAsyncResult ar)
        {
            if (ar is CompletedHttpAsyncResult)
            {
                CompletedHttpAsyncResult.End(ar);
            }
            else
            {
                hostedHttpRequestAsyncResultEnd.Invoke(null, new object[] {ar});
            }
        }
    }
}