C# Routing.RequestContext类代码示例

        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType != null && _container.Kernel.HasComponent(controllerType))
                return (IController)_container.Resolve(controllerType);

            return base.GetControllerInstance(requestContext, controllerType);
        }

 public EmailSendAttempt SendWelcome(RequestContext request, User u)
 {
     var template = LoadTemplate(
         "template-user-welcome",
         request.HttpContext.Server.MapPath("~/Messages/UserWelcome.template")
     );
     var url = new UrlHelper(request).Action(MVC.Public.Login.Index());
     var e = Builder.Transform(
         template,
         new TemplateData
             {
                 {"login", u.Login},
                 {"program", Application.ProgramName},
                 {"url", url.ToAbsoluteUrl(request.HttpContext.Request).ToString() },
             },
         request.HttpContext.Request
     );
     e.Recipient = new EmailAddress { Address = u.Email, Name = u.DisplayName };
    
     var attempt = Sender.Send(e);
     if (attempt.Success)
     {
         u.LastWeclomeEmailSent = DateTime.UtcNow;
         UserRepository.Save(u);
     }
     return attempt;
 }

        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
                throw new HttpException(404, string.Format("The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path));

            return (IController)kernel.Resolve(controllerType);
        }

        protected override void Initialize(RequestContext requestContext)
        {
            if (FormsService == null) { FormsService = new FormsAuthenticationService(); }
            if (MembershipService == null) { MembershipService = new AccountMembershipService(); }

            base.Initialize(requestContext);
        }

        public void Execute(RequestContext requestContext)
        {
            var urlType = requestContext.UrlStrongTypeFromRoute();
              using (log4net.NDC.Push(urlType.FullName))
              {
            var steps = StepsFor(requestContext, urlType);
            var stepContext = new StepContext(requestContext, urlType);

            if (!steps.Any())
            {
              HandleNoSteps(stepContext);
              return;
            }

            var lastContinuation = Continuation.Continue;
            foreach (var step in steps)
            {
              _log.Info("Step: " + step);
              lastContinuation = _stepInvoker.Invoke(step, stepContext);
              if (lastContinuation != Continuation.Continue)
              {
            break;
              }
            }

            if (lastContinuation == Continuation.Continue)
            {
              HandleNoEndingStep(stepContext);
              return;
            }

            _log.Info("Completed");
              }
        }

        /// <summary>
        /// Gets controller instance 
        /// </summary>
        /// <param name="requestContext">request context </param>
        /// <param name="controllerType">controloler that has been requested</param>
        /// <returns>IController</returns>
        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
                return base.GetControllerInstance(requestContext, controllerType);

            return DiContainer.Resolve<IController>(controllerType.FullName);
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            VirtualPathData path = base.GetVirtualPath(requestContext, values);

            if (path != null)
            {
                string virtualPath = path.VirtualPath;
                var lastIndexOf = virtualPath.LastIndexOf("?");

                if (lastIndexOf != 0)
                {
                    if (lastIndexOf > 0)
                    {
                        string leftPart = virtualPath.Substring(0, lastIndexOf).ToLowerInvariant();
                        string queryPart = virtualPath.Substring(lastIndexOf);
                        path.VirtualPath = leftPart + queryPart;
                    }
                    else
                    {
                        path.VirtualPath = path.VirtualPath.ToLowerInvariant();
                    }
                }
            }

            return path;
        }

 private static IHttpHandler GetRedirectHandlerWithDefaults(RequestContext requestContext)
 {
     var routeValues = requestContext.RouteData.Values;
     routeValues["culture"] = LocaleHelper.DefaultCulture;
     SetLocaleCookie(requestContext, LocaleHelper.DefaultCulture);
     return new RedirectHandler(new UrlHelper(requestContext).RouteUrl(routeValues));
 }

 private void SetUpRequestContext()
 {
     HttpTest.SetUpHttpContext();
     requestContext = new RequestContext();
     requestContext.HttpContext = new HttpContextWrapper(HttpContext.Current);
     requestContext.RouteData = new RouteData();
 }

        private ControllerContext ControllerContextFactory(RequestContext requestContext, string controllerName, string areaName)
        {
            try
            {
                IController controller = ControllerBuilder.Current.GetControllerFactory().CreateController(requestContext, controllerName);

                if (controller == null)
                {
                    return null;
                }

                if (areaName.HasValue() && !controller.GetType().FullName.Contains("Areas"))
                {
                    IList<Type> controllerTypes = controllerTypeCache.GetControllerTypes(controllerName) ?? new List<Type>();
                    Type controllerType = GetControllerByArea(controllerTypes, areaName);

                    controller = (IController)Activator.CreateInstance(controllerType);
                }

                return new ControllerContext(requestContext, controller as ControllerBase);
            }
            catch (Exception)
            {
                return null;
            }
        }

        private SiteMapNode AddNodeRecursive(XmlNode xmlNode, SiteMapNode parent, RequestContext context)
        {
            var routeValues = (from XmlNode attrib in xmlNode.Attributes
                               where !reservedNames.Contains(attrib.Name.ToLower())
                               select new { attrib.Name, attrib.Value }).ToDictionary(x => x.Name, x => (object)x.Value);

            RouteValueDictionary routeDict = new RouteValueDictionary(routeValues);
            VirtualPathData virtualPathData = RouteTable.Routes.GetVirtualPath(context, routeDict);

            if (virtualPathData == null)
            {
                string message = "RoutingSiteMapProvider is unable to locate Route for " +
                                 "Controller: '" + routeDict["controller"] + "', Action: '" + routeDict["action"] + "'. " +
                                 "Make sure a route has been defined for this SiteMap Node.";
                throw new InvalidOperationException(message);
            }

            string url = virtualPathData.VirtualPath;

            string title = xmlNode.Attributes["title"].Value;
            SiteMapNode node = new SiteMapNode(this, Guid.NewGuid().ToString(), url, title);

            base.AddNode(node, parent);

            foreach (XmlNode childNode in xmlNode.ChildNodes)
            {
                AddNodeRecursive(childNode, node, context);
            }

            return node;
        }

        /// <summary>
        /// Provides the object that processes the request.
        /// </summary>
        /// <param name="requestContext">An object that encapsulates information about the request.</param>
        /// <returns>An object that processes the request.</returns>
        public override IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            var handler = base.GetHttpHandler(requestContext);
            new PageInitializer().Initialize(handler);

            return handler;
        }

        public IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            if (_httpHandler == null)
                _httpHandler = new ApplicationRouteHttpHandler(_url, _assembly);

            return _httpHandler;
        }

        protected override IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            var culture = requestContext.RouteData.Values["culture"] as string;
            if (culture == null)
            {
                throw new InvalidOperationException("URL parameter 'culture' is required");
            }

            try
            {
                var ci = new CultureInfo(culture);
                Thread.CurrentThread.CurrentUICulture = ci;
                Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(ci.Name);

                // If route's culture is different from cookie's, update cookie
                var cookieLocale = requestContext.HttpContext.Request.Cookies["locale"];
                if (cookieLocale == null || cookieLocale.Value != culture)
                {
                    // Save route's culture to cookie
                    requestContext.HttpContext.Response.Cookies.Add(new HttpCookie("locale", culture));
                }
            }
            catch (CultureNotFoundException)
            {
                throw new InvalidOperationException("URL parameter 'culture' is invalid");
            }

            return base.GetHttpHandler(requestContext);
        }

        /// <summary>
        /// Retrieves the controller type for the specified name and request context.
        /// </summary>
        /// 
        /// <returns>
        /// The controller type.
        /// </returns>
        /// <param name="requestContext">The context of the HTTP request, which includes the HTTP context and route data.</param>
        /// <param name="controllerName">The name of the controller.</param>
        internal Type GetControllerTypeInternal(RequestContext requestContext, string controllerName)
        {
            var factory = _slaveFactories.Factories.FirstOrDefault(x => x.CanHandle(requestContext));
            if (factory != null)
            {
                //check to see if the factory is of type UmbracoControllerFactory which exposes the GetControllerType method so we don't have to create
                // an instance of the controller to figure out what it is. This is a work around for not having a breaking change for:
                // http://issues.umbraco.org/issue/U4-1726

                var umbFactory = factory as UmbracoControllerFactory;
                if (umbFactory != null)
                {
                    return umbFactory.GetControllerType(requestContext, controllerName);
                }
                //we have no choice but to instantiate the controller
                var instance = factory.CreateController(requestContext, controllerName);
                if (instance != null)
                {
                    return instance.GetType();    
                }
                return null;
            }

            return base.GetControllerType(requestContext, controllerName);
        }