public void Init(HttpApplication application)
{application.EndRequest += (o, e) => this.DeactivateInstancesForCurrentHttpRequest();
}public void DeactivateInstancesForCurrentHttpRequest()
{if (this.ReleaseScopeAtRequestEnd){var context = HttpContext.Current;this.MapKernels(kernel => kernel.Components.Get<ICache>().Clear(context));}
}

private static IKernel kernelInstance;public void Initialize(Func<IKernel> createKernelCallback)
{kernelInstance = createKernelCallback();kernelInstance.Components.GetAll<INinjectHttpApplicationPlugin>().Map(c => c.Start());kernelInstance.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();kernelInstance.Inject(this);
}public void ShutDown()
{if (kernelInstance != null){kernelInstance.Components.GetAll<INinjectHttpApplicationPlugin>().Map(c => c.Stop());kernelInstance.Dispose();kernelInstance = null;}
}

public void InitializeHttpApplication(HttpApplication httpApplication){    kernelInstance.Inject(httpApplication);}

private readonly OnePerRequestHttpModule onePerRequestHttpModule;private readonly IBootstrapper bootstrapper;protected NinjectHttpApplication()
{this.onePerRequestHttpModule = new OnePerRequestHttpModule();this.onePerRequestHttpModule.Init(this);this.bootstrapper = new Bootstrapper();
}public void Application_Start()
{lock (this){this.bootstrapper.Initialize(this.CreateKernel);this.onePerRequestHttpModule.ReleaseScopeAtRequestEnd = this.bootstrapper.Kernel.Settings.Get("ReleaseScopeAtRequestEnd", true);this.OnApplicationStarted();}
}public void Application_End()
{this.bootstrapper.ShutDown();this.OnApplicationStopped();
}protected abstract IKernel CreateKernel();protected virtual void OnApplicationStarted() { }protected virtual void OnApplicationStopped() { }

public override void Init(){    base.Init();    this.bootstrapper.InitializeHttpApplication(this);}

private IList<IHttpModule> httpModules;public void Init(HttpApplication context)
{this.httpModules = new Bootstrapper().Kernel.GetAll<IHttpModule>().ToList();foreach (var httpModule in this.httpModules){httpModule.Init(context);}
}public void Dispose()
{foreach (var httpModule in this.httpModules){httpModule.Dispose();}this.httpModules.Clear();
}

private readonly Func<IKernel> lazyKernel;public HttpApplicationInitializationHttpModule(Func<IKernel> lazyKernel)
{this.lazyKernel = lazyKernel;
}public void Init(HttpApplication context)
{this.lazyKernel().Inject(context);
}

[assembly: WebActivator.PreApplicationStartMethod(typeof(WebApplication1.App_Start.NinjectWebCommon), "Start")]
[assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(WebApplication1.App_Start.NinjectWebCommon), "Stop")]
public static class NinjectWebCommon
{private static readonly Bootstrapper bootstrapper = new Bootstrapper();/// <summary>/// Starts the application/// </summary>public static void Start() {DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));bootstrapper.Initialize(CreateKernel);}public static void Stop(){bootstrapper.ShutDown();}private static IKernel CreateKernel(){var kernel = new StandardKernel();kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();RegisterServices(kernel);return kernel;}private static void RegisterServices(IKernel kernel) { }
}

public override void Load()
{base.Load();this.Kernel.Components.Add<INinjectHttpApplicationPlugin, NinjectMvcHttpApplicationPlugin>();this.Kernel.Bind<IDependencyResolver>().To<NinjectDependencyResolver>();this.Kernel.Bind<IFilterProvider>().To<NinjectFilterAttributeFilterProvider>();this.Kernel.Bind<IFilterProvider>().To<NinjectFilterProvider>();this.Kernel.Bind<RouteCollection>().ToConstant(RouteTable.Routes);this.Kernel.Bind<HttpContext>().ToMethod(ctx => HttpContext.Current).InTransientScope();this.Kernel.Bind<HttpContextBase>().ToMethod(ctx => new HttpContextWrapper(HttpContext.Current)).InTransientScope();this.Kernel.Bind<ModelValidatorProvider>().To<NinjectDataAnnotationsModelValidatorProvider>();//this.Kernel.Bind<IModelBinderProvider>().To<NinjectModelBinderProvider>();//this.Kernel.Bind<IModelBinder>().To<NinjectModelBinder>();
}

public class StandardKernel : KernelBase
{public StandardKernel(params INinjectModule[] modules) : base(modules){}
}public abstract class KernelBase : BindingRoot, IKernel
{protected KernelBase(): this(new ComponentContainer(), new NinjectSettings(), new INinjectModule[0]){}protected KernelBase(IComponentContainer components, INinjectSettings settings, params INinjectModule[] modules){if (this.Settings.LoadExtensions){this.Load(this.Settings.ExtensionSearchPatterns);}}
}

public class NinjectSettings : INinjectSettings
{public bool LoadExtensions{get { return Get("LoadExtensions", true); }set { Set("LoadExtensions", value); }}public string[] ExtensionSearchPatterns{get { return Get("ExtensionSearchPatterns", new [] { "Ninject.Extensions.*.dll", "Ninject.Web*.dll" }); }set { Set("ExtensionSearchPatterns", value); }}
}

public void Load(IEnumerable<string> filePatterns)
{var moduleLoader = this.Components.Get<IModuleLoader>();moduleLoader.LoadModules(filePatterns);
}

public void LoadModules(IEnumerable<string> patterns)
{var plugins = Kernel.Components.GetAll<IModuleLoaderPlugin>();var fileGroups = patterns.SelectMany(pattern => GetFilesMatchingPattern(pattern)).GroupBy(filename => Path.GetExtension(filename).ToLowerInvariant());foreach (var fileGroup in fileGroups){string extension = fileGroup.Key;IModuleLoaderPlugin plugin = plugins.Where(p => p.SupportedExtensions.Contains(extension)).FirstOrDefault();if (plugin != null)plugin.LoadModules(fileGroup);}
}

public class CompiledModuleLoaderPlugin : NinjectComponent, IModuleLoaderPlugin
{public void LoadModules(IEnumerable<string> filenames){var assembliesWithModules = this.assemblyNameRetriever.GetAssemblyNames(filenames, asm => asm.HasNinjectModules());this.Kernel.Load(assembliesWithModules.Select(asm => Assembly.Load(asm)));}
}

public class AssemblyNameRetriever : NinjectComponent, IAssemblyNameRetriever
{public IEnumerable<AssemblyName> GetAssemblyNames(IEnumerable<string> filenames, Predicate<Assembly> filter){var assemblyCheckerType = typeof(AssemblyChecker);var temporaryDomain = CreateTemporaryAppDomain();try{var checker = (AssemblyChecker)temporaryDomain.CreateInstanceAndUnwrap(assemblyCheckerType.Assembly.FullName,assemblyCheckerType.FullName ?? string.Empty);return checker.GetAssemblyNames(filenames.ToArray(), filter);}}
}

private class AssemblyChecker : MarshalByRefObject
{public IEnumerable<AssemblyName> GetAssemblyNames(IEnumerable<string> filenames, Predicate<Assembly> filter){var result = new List<AssemblyName>();foreach (var filename in filenames){Assembly assembly = Assembly.Load(filename);if (filter(assembly)){result.Add(assembly.GetName(false));}}return result;}
}

internal static class ExtensionsForAssembly
{public static bool HasNinjectModules(this Assembly assembly){return assembly.GetExportedTypes().Any(IsLoadableModule);}public static IEnumerable<INinjectModule> GetNinjectModules(this Assembly assembly){return assembly.GetExportedTypes().Where(IsLoadableModule).Select(type => Activator.CreateInstance(type) as INinjectModule);}private static bool IsLoadableModule(Type type){return typeof(INinjectModule).IsAssignableFrom(type)&& !type.IsAbstract&& !type.IsInterface&& type.GetConstructor(Type.EmptyTypes) != null;}
}

public void Load(IEnumerable<Assembly> assemblies)
{this.Load(assemblies.SelectMany(asm => asm.GetNinjectModules()));
}public void Load(IEnumerable<INinjectModule> m)
{Ensure.ArgumentNotNull(m, "modules");m = m.ToList();foreach (INinjectModule module in m){module.OnLoad(this);this.modules.Add(module.Name, module);}
}

private readonly IResolutionRoot resolutionRoot;public object GetService(Type serviceType)
{var request = this.resolutionRoot.CreateRequest(serviceType, null, new Parameter[0], true, true);return this.resolutionRoot.Resolve(request).SingleOrDefault();
}public IEnumerable<object> GetServices(Type serviceType)
{return this.resolutionRoot.GetAll(serviceType).ToList();
}

public void Start()
{ModelValidatorProviders.Providers.Remove(ModelValidatorProviders.Providers.OfType<DataAnnotationsModelValidatorProvider>().Single());DependencyResolver.SetResolver(this.CreateDependencyResolver());RemoveDefaultAttributeFilterProvider();
}protected IDependencyResolver CreateDependencyResolver()
{return this.kernel.Get<IDependencyResolver>();
}

this.Bind<IKernel>().ToConstant(this).InTransientScope();
this.Bind<IResolutionRoot>().ToConstant(this).InTransientScope();