1   [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
 2         public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces) {
 3             if (routes == null) {
 4                 throw new ArgumentNullException("routes");
 5             }
 6             if (url == null) {
 7                 throw new ArgumentNullException("url");
 8             }
 9 
10             Route route = new Route(url, new MvcRouteHandler()) {
11                 Defaults = new RouteValueDictionary(defaults),
12                 Constraints = new RouteValueDictionary(constraints),
13                 DataTokens = new RouteValueDictionary()
14             };
15 
16             if ((namespaces != null) && (namespaces.Length > 0)) {
17                 route.DataTokens["Namespaces"] = namespaces;
18             }
19 
20             routes.Add(name, route);
21 
22             return route;
23         }

 1    public class UrlRoutingModule : IHttpModule {     
 2 
 3         protected virtual void Init(HttpApplication application) {
 4           
 5             application.PostResolveRequestCache += OnApplicationPostResolveRequestCache;
 6         } 
 7  
 8         private void OnApplicationPostResolveRequestCache(object sender, EventArgs e) {
 9             HttpContextBase context = new HttpContextWrapper(((HttpApplication)sender).Context); 
10             PostResolveRequestCache(context);
11         }      
12 
13         public virtual void PostResolveRequestCache(HttpContextBase context) { 
14             // Match the incoming URL against the route table
15             RouteData routeData = RouteCollection.GetRouteData(context);
16 
17             // Do nothing if no route found 
18             if (routeData == null) {
19                 return; 
20             } 
21 
22             // If a route was found, get an IHttpHandler from the route's RouteHandler 
23             IRouteHandler routeHandler = routeData.RouteHandler;           
24 
25             RequestContext requestContext = new RequestContext(context, routeData);
26 
27             // Remap IIS7 to our handler
28             context.RemapHandler(httpHandler); 
29         }
30     }

 1     public RouteData GetRouteData(HttpContextBase httpContext) {
 2             if (httpContext == null) { 
 3                 throw new ArgumentNullException("httpContext"); 
 4             }
 5             if (httpContext.Request == null) { 
 6                 throw new ArgumentException(SR.GetString(SR.RouteTable_ContextMissingRequest), "httpContext");
 7             }
 8 
 9             // Optimize performance when the route collection is empty.  The main improvement is that we avoid taking 
10 // a read lock when the collection is empty.  Without this check, the UrlRoutingModule causes a 25%-50%
11 // regression in HelloWorld RPS due to lock contention.  Robbin:The UrlRoutingModule is now in the root web.config, 
12 // so we need to ensure the module is performant, especially when you are not using routing. 
13 // This check does introduce a slight bug, in that if a writer clears the collection as part of a write
14 // transaction, a reader may see the collection when it's empty, which the read lock is supposed to prevent. 
15 // We will investigate a better fix in Dev10 Beta2.  The Beta1 bug is Dev10 652986.
16             if (Count == 0) {
17                 return null;
18             } 
19 
20             if (!RouteExistingFiles) { 
21                 string requestPath = httpContext.Request.AppRelativeCurrentExecutionFilePath; 
22                 if ((requestPath != "~/") &&
23                     (_vpp != null) && 
24                     (_vpp.FileExists(requestPath) ||
25                     _vpp.DirectoryExists(requestPath))) {
26                     // If we're not routing existing files and the file exists, we stop processing routes
27                     return null; 
28                 }
29             } 
30  
31             // Go through all the configured routes and find the first one that returns a match
32             using (GetReadLock()) { 
33                 foreach (RouteBase route in this) {
34                     RouteData routeData = route.GetRouteData(httpContext);
35                     if (routeData != null) {
36                         return routeData; 
37                     }
38                 } 
39             } 
40 
41             return null; 
42         }

 1 public void RemapHandler(IHttpHandler handler) { 
 2             IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
 3  
 4             if (wr != null) {
 5                 // Remap handler not allowed after ResolveRequestCache notification
 6                 if (_notificationContext.CurrentNotification >= RequestNotification.MapRequestHandler) {
 7                     throw new InvalidOperationException(SR.GetString(SR.Invoke_before_pipeline_event, "HttpContext.RemapHandler", "HttpApplication.MapRequestHandler")); 
 8                 }
 9  
10                 string handlerTypeName = null; 
11                 string handlerName = null;
12  
13                 if (handler != null) {
14                     Type handlerType = handler.GetType();
15 
16                     handlerTypeName = handlerType.AssemblyQualifiedName; 
17                     handlerName = handlerType.FullName;
18                 } 
19  
20                 wr.SetRemapHandler(handlerTypeName, handlerName);
21             } 
22 
23             _remapHandler = handler;
24         }
25

 1   public class MvcRouteHandler : IRouteHandler {
 2         private IControllerFactory _controllerFactory;
 3 
 4         public MvcRouteHandler() {
 5         }
 6 
 7         public MvcRouteHandler(IControllerFactory controllerFactory) {
 8             _controllerFactory = controllerFactory;
 9         }
10 
11         protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext) {
12             requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));
13             return new MvcHandler(requestContext);
14         }
15 
16         protected virtual SessionStateBehavior GetSessionStateBehavior(RequestContext requestContext) {
17             string controllerName = (string)requestContext.RouteData.Values["controller"];
18             IControllerFactory controllerFactory = _controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();
19             return controllerFactory.GetControllerSessionBehavior(requestContext, controllerName);
20         }
21 
22         #region IRouteHandler Members
23         IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext) {
24             return GetHttpHandler(requestContext);
25         }
26         #endregion
27     }

 1         private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory) {
 2             // If request validation has already been enabled, make it lazy. This allows attributes like [HttpPost] (which looks
 3 // at Request.Form) to work correctly without triggering full validation.
 4             bool? isRequestValidationEnabled = ValidationUtility.IsValidationEnabled(HttpContext.Current);
 5             if (isRequestValidationEnabled == true) {
 6                 ValidationUtility.EnableDynamicValidation(HttpContext.Current);
 7             }
 8 
 9             AddVersionHeader(httpContext);
10             RemoveOptionalRoutingParameters();
11 
12             // Get the controller type
13             string controllerName = RequestContext.RouteData.GetRequiredString("controller");
14 
15             // Instantiate the controller and call Execute
16             factory = ControllerBuilder.GetControllerFactory();
17             controller = factory.CreateController(RequestContext, controllerName);
18             if (controller == null) {
19                 throw new InvalidOperationException(
20                     String.Format(
21                         CultureInfo.CurrentCulture,
22                         MvcResources.ControllerBuilder_FactoryReturnedNull,
23                         factory.GetType(),
24                         controllerName));
25             }
26         }

 1 #if NUGET
 2 [assembly: WebActivator.PreApplicationStartMethod(typeof(SampleApplication.App_Start.NinjectMVC3), "Start")]
 3 [assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(SampleApplication.App_Start.NinjectMVC3), "Stop")]
 4 
 5 namespace SampleApplication.App_Start
 6 {
 7     using System.Reflection;
 8     using Microsoft.Web.Infrastructure.DynamicModuleHelper;
 9     using Ninject;
10     using Ninject.Web.Mvc;
11 
12     public static class NinjectMVC3 
13     {
14         private static readonly Bootstrapper bootstrapper = new Bootstrapper();
15 
16         /// <summary>
17 /// Starts the application
18 /// </summary>
19         public static void Start() 
20         {
21             DynamicModuleUtility.RegisterModule(typeof(OnePerRequestModule));
22             DynamicModuleUtility.RegisterModule(typeof(HttpApplicationInitializationModule));
23             bootstrapper.Initialize(CreateKernel);
24         }
25         
26         /// <summary>
27 /// Stops the application.
28 /// </summary>
29         public static void Stop()
30         {
31             bootstrapper.ShutDown();
32         }
33         
34         /// <summary>
35 /// Creates the kernel that will manage your application.
36 /// </summary>
37 /// <returns>The created kernel.</returns>
38         private static IKernel CreateKernel()
39         {
40             var kernel = new StandardKernel();
41             RegisterServices(kernel);
42             return kernel;
43         }
44 
45         /// <summary>
46 /// Load your modules or register your services here!
47 /// </summary>
48 /// <param name="kernel">The kernel.</param>
49         private static void RegisterServices(IKernel kernel)
50         {
51             kernel.Load(Assembly.GetExecutingAssembly());
52         }        
53     }
54 }
55 #endif

 1   public class Bootstrapper: IBootstrapper
 2     {
 3         /// <summary>
 4 /// The ninject kernel of the application
 5 /// </summary>
 6         protected static IKernel kernelInstance;
 7 
 8         /// <summary>
 9 /// Gets the kernel.
10 /// </summary>
11         [Obsolete("Do not use Ninject as Service Locator")]
12         public IKernel Kernel
13         {
14             get { return kernelInstance; }
15         }
16 
17         /// <summary>
18 /// Starts the application.
19 /// </summary>
20 /// <param name="createKernelCallback">The create kernel callback function.</param>
21         public void Initialize(Func<IKernel> createKernelCallback)
22         {
23             if (kernelInstance != null)
24             {
25                 throw new InvalidOperationException("Already Initialized!");
26             }
27 
28             kernelInstance = createKernelCallback();
29 
30             kernelInstance.Bind<IResolutionRoot>().ToConstant(kernelInstance);
31             kernelInstance.Bind<IDependencyResolver>().To<NinjectDependencyResolver>();
32             kernelInstance.Bind<IFilterProvider>().To<NinjectFilterAttributeFilterProvider>();
33             kernelInstance.Bind<IFilterProvider>().To<NinjectFilterProvider>();
34             kernelInstance.Bind<RouteCollection>().ToConstant(RouteTable.Routes);
35             kernelInstance.Bind<HttpContext>().ToMethod(ctx => HttpContext.Current).InTransientScope();
36             kernelInstance.Bind<HttpContextBase>().ToMethod(ctx => new HttpContextWrapper(HttpContext.Current)).InTransientScope();
37             kernelInstance.Bind<ModelValidatorProvider>().To<NinjectDataAnnotationsModelValidatorProvider>();
38 
39             ModelValidatorProviders.Providers.Remove(ModelValidatorProviders.Providers.OfType<DataAnnotationsModelValidatorProvider>().Single());
40             DependencyResolver.SetResolver(CreateDependencyResolver());
41             RemoveDefaultAttributeFilterProvider();
42         }
43 
44         /// <summary>
45 /// Initializes a HttpApplication instance.
46 /// </summary>
47 /// <param name="httpApplication">The HttpApplication instance.</param>
48         public void InitializeHttpApplication(HttpApplication httpApplication)
49         {
50             kernelInstance.Inject(httpApplication);
51         }
52 
53         /// <summary>
54 /// Releases the kernel on application end.
55 /// </summary>
56         public void ShutDown()
57         {
58             if (kernelInstance != null)
59             {
60                 kernelInstance.Dispose();
61                 kernelInstance = null;
62             }
63         }
64 
65         /// <summary>
66 /// Creates the controller factory that is used to create the controllers.
67 /// </summary>
68 /// <returns>The created controller factory.</returns>
69         private static IDependencyResolver CreateDependencyResolver()
70         {
71             return kernelInstance.Get<IDependencyResolver>();
72         }
73 
74         /// <summary>
75 /// Removes the default attribute filter provider.
76 /// </summary>
77         private static void RemoveDefaultAttributeFilterProvider()
78         {
79             var oldFilter = FilterProviders.Providers.Single(f => f is FilterAttributeFilterProvider);
80             FilterProviders.Providers.Remove(oldFilter);
81         }
82     }

 1 public class AccountController : Controller
 2 {
 3 
 4 　　private IAccountManater _accountManager;
 5 
 6 　　public AccountController (IAccountManater accountManager)
 7 
 8 　　{
 9 
10 　　　　_accountManager = accountManager;
11 
12 　　}
13 
14 [HttpPost]
15 public ActionResult LogOn(LogOnModel model, string returnUrl)
16 {
17 
18 　　if(_accountManager.Has(model))
19 
20 　　　　return view("ok");
21 
22 　　else
23 
24 　　　　return view("error");
25 　　}
26 
27 }