/// <summary> /// 获取可能与指定路由规则冲突的路由规则 /// </summary> /// <param name="rule">要检查冲突的路由规则</param> /// <returns>可能与之冲突的路由规则</returns> public SimpleRouteRule GetConflictRule(SimpleRouteRule rule) { var virtualPath = rule.GetVirtualPathDescriptor(); var routeValues = rule.GetRouteValuesDescriptor(); return(GetConflict(virtualPath, routeValues)); }
/// <summary> /// 在冲突检测表中添加一条记录,并检测与现有规则是否冲突。 /// </summary> /// <param name="rule">要添加的规则</param> /// <param name="conflictRule">与之相冲突的规则,如果有的话</param> /// <returns>是否成功</returns> public bool AddRuleAndCheckConflict(SimpleRouteRule rule, out SimpleRouteRule conflictRule) { var virtualPath = rule.GetVirtualPathDescriptor(); var routeValues = rule.GetRouteValuesDescriptor(); lock ( _sync ) { if (virtualPathList.TryGetValue(virtualPath, out conflictRule)) { return(false); } if (routeValuesList.TryGetValue(routeValues, out conflictRule)) { return(false); } conflictRule = null; virtualPathList.Add(virtualPath, rule); routeValuesList.Add(routeValues, rule); return(true); } }
/// <summary> /// 检查两个路由规则是否互斥。 /// </summary> /// <param name="rule1">路由规则1</param> /// <param name="rule2">路由规则2</param> /// <returns></returns> public static bool Mutex(SimpleRouteRule rule1, SimpleRouteRule rule2) { var KeySet = new HashSet <string>(rule1.StaticRouteValues.Keys, StringComparer.OrdinalIgnoreCase); var KeySet2 = new HashSet <string>(rule2.StaticRouteValues.Keys, StringComparer.OrdinalIgnoreCase); KeySet.IntersectWith(KeySet2); return(KeySet.Any(key => !rule1.StaticRouteValues[key].Equals(rule2.StaticRouteValues[key], StringComparison.OrdinalIgnoreCase))); }
/// <summary> /// 创建 VirtualPathData 对象 /// </summary> /// <param name="virtualPath">虚拟路径</param> /// <param name="rule">产生该虚拟路径的路由规则</param> /// <returns>VirtualPathData 对象</returns> protected VirtualPathData CreateVirtualPathData(string virtualPath, SimpleRouteRule rule) { var data = new VirtualPathData(this, virtualPath); foreach (var pair in rule.DataTokens) { data.DataTokens.Add(pair.Key, pair.Value); } data.DataTokens["RoutingRuleName"] = rule.Name; return(data); }
/// <summary> /// 添加一个路由规则 /// </summary> /// <param name="rule">路由规则</param> protected virtual SimpleRouteRule AddRule(SimpleRouteRule rule) { SimpleRouteRule conflictRule; if (!AddRuleAndCheckConflict(rule, out conflictRule)) { throw new InvalidOperationException(string.Format("添加规则\"{0}\"失败,路由表 \"{1}\" 中已经存在一条可能冲突的规则:\"{2}\"", rule.Name, conflictRule.SimpleRouteTable.Name, conflictRule.Name)); } _rules.Add(rule); rule.SimpleRouteTable = this; return(rule); }
/// <summary> /// 比较两个路由规则约束是否一致 /// </summary> /// <param name="rule">要比较的路由规则</param> /// <returns>两个规则的约束是否一致</returns> public bool EqualsConstraints(SimpleRouteRule rule) { if (rule == null) { throw new ArgumentNullException("rule"); } if (rule.StaticRouteValues.Count != StaticRouteValues.Count) { return(false); } return(IsMatch(rule.StaticRouteValues)); }
/// <summary> /// 添加一个路由规则 /// </summary> /// <param name="name">规则名称</param> /// <param name="urlPattern">URL 模式</param> /// <param name="routeValues">静态/默认路由值</param> /// <param name="queryKeys">可用于 QueryString 的参数,若为null则表示无限制</param> public virtual SimpleRouteRule AddRule(string name, string urlPattern, IDictionary <string, string> routeValues, string[] queryKeys) { if (urlPattern == null) { throw new ArgumentNullException("urlPattern"); } if (routeValues == null) { throw new ArgumentNullException("routeValues"); } var rule = new SimpleRouteRule(name, urlPattern, routeValues, queryKeys); return(AddRule(rule)); }
/// <summary> /// 尝试冲突检测表中添加一条记录,并检测与现有规则是否冲突,若有冲突则无法添加成功 /// </summary> /// <param name="rule">要添加的规则</param> /// <param name="conflictRule">与之相冲突的规则,如果有的话</param> /// <returns>是否添加成功</returns> public bool TryAddRule(SimpleRouteRule rule, out SimpleRouteRule conflictRule) { var virtualPath = rule.GetVirtualPathDescriptor(); var routeValues = rule.GetRouteValuesDescriptor(); lock ( _sync ) { conflictRule = GetConflict(virtualPath, routeValues); if (conflictRule != null) { return(false); } virtualPathList.Add(virtualPath, rule); routeValuesList.Add(routeValues, rule); return(true); } }
/// <summary> /// 添加一个路由规则 /// </summary> /// <param name="name">规则名称</param> /// <param name="urlPattern">URL 模式</param> /// <param name="routeValues">静态/默认路由值</param> /// <param name="queryKeys">可用于 QueryString 的参数,若为null则表示无限制</param> public virtual SimpleRouteRule AddRule(string name, string verb, bool oneway, string urlPattern, IDictionary <string, string> routeValues, IReadOnlyCollection <string> queryKeys) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (urlPattern == null) { throw new ArgumentNullException(nameof(urlPattern)); } if (routeValues == null) { throw new ArgumentNullException(nameof(routeValues)); } if (urlPattern.StartsWith("~/") == false) { if (urlPattern.StartsWith("/")) { throw new ArgumentException("urlPattern has invalid format", "urlPattern"); } urlPattern = "~/" + urlPattern; } urlPattern = Regex.Replace(urlPattern, "/+", "/"); if (urlPattern.Any() && urlPattern.EndsWith("/") == false) { urlPattern += "/"; } var rule = new SimpleRouteRule(name, urlPattern, null, oneway, routeValues, queryKeys); return(AddRule(rule)); }
/// <summary> /// 在冲突检测表中添加一条记录,并检测与现有规则是否冲突。 /// </summary> /// <param name="rule">要添加的规则</param> /// <param name="conflictRule">与之相冲突的规则,如果有的话</param> /// <returns>是否成功</returns> public bool AddRuleAndCheckConflict( SimpleRouteRule rule, out SimpleRouteRule conflictRule ) { var virtualPath = rule.GetVirtualPathDescriptor(); var routeValues = rule.GetRouteValuesDescriptor(); lock ( _sync ) { if ( virtualPathList.TryGetValue( virtualPath, out conflictRule ) ) return false; if ( routeValuesList.TryGetValue( routeValues, out conflictRule ) ) return false; conflictRule = null; virtualPathList.Add( virtualPath, rule ); routeValuesList.Add( routeValues, rule ); return true; } }
/// <summary> /// 检查两个路由规则是否互斥。 /// </summary> /// <param name="rule1">路由规则1</param> /// <param name="rule2">路由规则2</param> /// <returns></returns> public static bool Mutex( SimpleRouteRule rule1, SimpleRouteRule rule2 ) { var KeySet = new HashSet<string>( rule1.StaticRouteValues.Keys, StringComparer.OrdinalIgnoreCase ); var KeySet2 = new HashSet<string>( rule2.StaticRouteValues.Keys, StringComparer.OrdinalIgnoreCase ); KeySet.IntersectWith( KeySet2 ); return KeySet.Any( key => !rule1.StaticRouteValues[key].EqualsIgnoreCase( rule2.StaticRouteValues[key] ) ); }
/// <summary> /// 添加一个路由规则 /// </summary> /// <param name="rule">路由规则</param> protected virtual SimpleRouteRule AddRule( SimpleRouteRule rule ) { SimpleRouteRule conflictRule; if ( !AddRuleAndCheckConflict( rule, out conflictRule ) ) throw new InvalidOperationException( string.Format( "添加规则\"{0}\"失败,路由表 \"{1}\" 中已经存在一条可能冲突的规则:\"{2}\"", rule.Name, conflictRule.SimpleRouteTable.Name, conflictRule.Name ) ); _rules.Add( rule ); rule.SimpleRouteTable = this; return rule; }
/// <summary> /// 添加一个路由规则 /// </summary> /// <param name="name">规则名称</param> /// <param name="urlPattern">URL 模式</param> /// <param name="routeValues">静态/默认路由值</param> /// <param name="queryKeys">可用于 QueryString 的参数,若为null则表示无限制</param> public virtual SimpleRouteRule AddRule( string name, string urlPattern, IDictionary<string, string> routeValues, string[] queryKeys ) { if ( urlPattern == null ) throw new ArgumentNullException( "urlPattern" ); if ( routeValues == null ) throw new ArgumentNullException( "routeValues" ); var rule = new SimpleRouteRule( name, urlPattern, routeValues, queryKeys ); return AddRule( rule ); }
/// <summary> /// 在冲突检测表中添加一条规则并检查冲突 /// </summary> /// <param name="rule">要添加的规则</param> /// <param name="conflictRule">与之相冲突的规则</param> /// <returns>是否添加成功</returns> public static bool AddRuleAndCheckConflict( SimpleRouteRule rule, out SimpleRouteRule conflictRule ) { return conflictCheckList.AddRuleAndCheckConflict( rule, out conflictRule ); }
/// <summary> /// 比较两个路由规则约束是否一致 /// </summary> /// <param name="rule">要比较的路由规则</param> /// <returns>两个规则的约束是否一致</returns> public bool EqualsConstraints( SimpleRouteRule rule ) { if ( rule == null ) throw new ArgumentNullException( "rule" ); if ( rule.StaticRouteValues.Count != StaticRouteValues.Count ) return false; return IsMatch( rule.StaticRouteValues ); }
/// <summary> /// 创建 VirtualPathData 对象 /// </summary> /// <param name="virtualPath">虚拟路径</param> /// <param name="rule">产生该虚拟路径的路由规则</param> /// <returns>VirtualPathData 对象</returns> protected VirtualPathData CreateVirtualPathData(VirtualPathContext context, string virtualPath, SimpleRouteRule rule) { virtualPath = Regex.Replace(virtualPath, "^~", context.HttpContext.Request.PathBase); var data = new VirtualPathData(this, virtualPath); foreach (var pair in rule.DataTokens) { data.DataTokens.Add(pair.Key, pair.Value); } data.DataTokens["RoutingRuleName"] = rule.Name; return(data); }
/// <summary> /// 在冲突检测表中添加一条规则并检查冲突 /// </summary> /// <param name="rule">要添加的规则</param> /// <param name="conflictRule">与之相冲突的规则</param> /// <returns>是否添加成功</returns> public static bool AddRuleAndCheckConflict(SimpleRouteRule rule, out SimpleRouteRule conflictRule) { return(conflictCheckList.AddRuleAndCheckConflict(rule, out conflictRule)); }
/// <summary> /// 创建 VirtualPathData 对象 /// </summary> /// <param name="virtualPath">虚拟路径</param> /// <param name="rule">产生该虚拟路径的路由规则</param> /// <returns>VirtualPathData 对象</returns> protected VirtualPathData CreateVirtualPathData( string virtualPath, SimpleRouteRule rule ) { var data = new VirtualPathData( this, virtualPath ); foreach ( var pair in rule.DataTokens ) data.DataTokens.Add( pair.Key, pair.Value ); data.DataTokens["RoutingRuleName"] = rule.Name; return data; }