C# IRouteHandler类代码示例

 /// <summary>
 /// 初始化一个<see cref="RewriteLowerCaseUrlRoute"/>类的新实例
 /// </summary>
 /// <param name="url"> </param>
 /// <param name="defaults"> </param>
 /// <param name="constraints"> </param>
 /// <param name="dataTokens"> </param>
 /// <param name="routeHandler"> </param>
 public RewriteLowerCaseUrlRoute(string url,
     RouteValueDictionary defaults,
     RouteValueDictionary constraints,
     RouteValueDictionary dataTokens,
     IRouteHandler routeHandler)
     : base(url, defaults, constraints, dataTokens, routeHandler)
 { }

 /// <summary>
 /// Initializes a new instance of the <see cref="UIRoute"/> class.
 /// </summary>
 /// <param name="url">The URL.</param>
 /// <param name="defaults">The defaults.</param>
 /// <param name="routeHandler">The route handler.</param>
 public UIRoute(string url, RouteValueDictionary defaults, IRouteHandler routeHandler)
     : base(url, defaults, routeHandler)
 {
     _url = url;
     _defaults = defaults;
     _routeHandler = routeHandler;
 }

 public static void MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, IRouteHandler routeHandler)
 {
     var newRoute = new NamedRoute(name, url, routeHandler);
     newRoute.Defaults = new RouteValueDictionary(defaults);
     newRoute.Constraints = new RouteValueDictionary(constraints);
     routes.Add(name, newRoute);
 }

        static Mock<RequestContext> GetRequestContext(string requestUrl, string routeUrl, IRouteHandler handler)
        {
            var route = new Route(routeUrl, handler);

            var sv = new Mock<NameValueCollection>(MockBehavior.Strict);
            sv.Setup(m => m.Get("IIS_UrlRewriteModule")).Returns((string)null);

            var req = new Mock<HttpRequestBase>(MockBehavior.Strict);
            req.Setup(m => m.AppRelativeCurrentExecutionFilePath).Returns("~/");
            req.Setup(m => m.PathInfo).Returns(requestUrl);
            req.Setup(m => m.ApplicationPath).Returns("/");
            req.Setup(m => m.ServerVariables).Returns(sv.Object);

            var resp = new Mock<HttpResponseBase>(MockBehavior.Strict);
            resp.Setup(m => m.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(url => url);

            var ctx = new Mock<HttpContextBase>(MockBehavior.Strict);
            ctx.Setup(m => m.Request).Returns(req.Object);
            ctx.Setup(m => m.Response).Returns(resp.Object);

            var reqCtx = new Mock<RequestContext>(MockBehavior.Strict);
            reqCtx.Setup(m => m.HttpContext).Returns(ctx.Object);
            reqCtx.Setup(m => m.RouteData).Returns(route.GetRouteData(ctx.Object));

            return reqCtx;
        }

        public CultureSensitiveRouteHandler(IRouteHandler routeHandler)
        {
            RouteHandler = routeHandler;

            SetCurrentCulture = true;
            SetCurrentUICulture = true;
        }

 /// <summary>
 /// 创建一个简单路由表实例
 /// </summary>
 /// <param name="name">简单路由表名称</param>
 /// <param name="handler">处理路由请求的对象</param>
 /// <param name="mvcCompatible">是否产生MVC兼容的虚拟路径（去除~/）</param>
 public SimpleRouteTable( string name, IRouteHandler handler, bool mvcCompatible )
 {
     Name = name;
       Handler = handler;
       MvcCompatible = mvcCompatible;
       UrlEncoding = Encoding.UTF8;
 }

 /// <summary>
 /// Creates a new ContentNegotiationRouteProxy.
 /// </summary>
 /// <param name="proxiedHandler">The handler to proxy, typically an MvcRouteHandler</param>
 /// <param name="map">The map containing the associations between media types and formats</param>
 /// <param name="priority">Whether the client sets the priority or the server.  The HTTP spec
 /// indicates that the client should set it, but on occasion the server may need to set it
 /// to work around bugs in browsers (e.g. Chrome prioritizes xml over html).</param>
 public ContentNegotiationRouteProxy(IRouteHandler proxiedHandler, MediaTypeFormatMap map,
     ConnegPriorityGivenTo priority = ConnegPriorityGivenTo.Client)
 {
     this.proxiedHandler = proxiedHandler;
     this.map = map;
     this.priority = priority;
 }

        public TranslationRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints,
			RouteValueDictionary dataTokens, IRouteHandler routeHandler)
            : base(url, defaults, constraints, dataTokens, routeHandler)
        {
            TranslationRouteRoot = this;
            TranslatedRoutes = new Dictionary<string, TranslationRoute>();
        }

        public ShortyRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler)
            : base(url, defaults, constraints, dataTokens, routeHandler)
        {
            if (string.IsNullOrEmpty(url)) throw new ArgumentNullException("Route url must be defined", "url");

            var thisUrl = url;
        }

 public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler) {
     Url = url;
     Defaults = defaults;
     Constraints = constraints;
     DataTokens = dataTokens;
     RouteHandler = routeHandler;
 }

        public LocaleRoute(
                    string pattern, 
                    RouteValueDictionary defaults, 
                    RouteValueDictionary constraints,
                    RouteValueDictionary tokens,
                    string[] namespaces,
                    IRouteHandler routeHandler)
        {
            var localeConstraints = new RouteValueDictionary(constraints);
            localeConstraints.Add("locale", @"[a-zA-Z]{2}");

            _routeWithLocale = new Route(
                                    @"{locale}/" + pattern,
                                    defaults,
                                    localeConstraints,
                                    tokens,
                                    new LocaleRouteHandler(routeHandler));

            _routeWithoutLocale = new Route(
                                        pattern,
                                        defaults,
                                        constraints,
                                        tokens,
                                        new LocaleRouteHandler(routeHandler));

            if(namespaces != null && namespaces.Any()) {
                _routeWithLocale.DataTokens["Namespaces"] = namespaces;
                _routeWithoutLocale.DataTokens["Namespaces"] = namespaces;
            }
        }

 public NamedRoute(string name, string displayName, string url, RouteValueDictionary defaults, RouteValueDictionary constraints,
                   RouteValueDictionary dataTokens, IRouteHandler routeHandler)
     : base(url, defaults, constraints, dataTokens, routeHandler)
 {
     _name = name;
     _displayName = displayName;
 }

 public PortalableRoute(string url, RouteValueDictionary constraints, IRouteHandler routeHandler)
     : base(url, null, constraints, routeHandler)
 {
     //Url = url;
     //Constraints = constraints;
     //RouteHandler = routeHandler;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="KarbonRoute"/> class.
 /// </summary>
 /// <param name="url">The URL pattern for the route.</param>
 /// <param name="routeHandler">The object that processes requests for the route.</param>
 public KarbonRoute(string url, 
     IRouteHandler routeHandler)
     : base(url, routeHandler)
 {
     _url = url;
     _routeHandler = routeHandler;
 }

 public RouteData(RouteBase route, IRouteHandler routeHandler)
 {
     this._values = new RouteValueDictionary();
     this._dataTokens = new RouteValueDictionary();
     this.Route = route;
     this.RouteHandler = routeHandler;
 }