/// <summary>
/// 检查指定规则是否与简单路由表现存的任何规则冲突，若有冲突，返回与其冲突的规则。
/// </summary>
/// <param name="rule">要检查冲突的规则</param>
/// <returns>如果现存规则与检查的规则存在一个冲突，则返回冲突的规则。</returns>
public SimpleRouteRule CheckConflict(SimpleRouteRule rule)
{
//验证 GetVirtualPath 时可能的冲突
{
var conflictRule = _rules
.Where(r => r.RouteKeys.Length == rule.RouteKeys.Length) //若通过RouteKey多寡无法区分
.Where(r => r.DynamicRouteKyes.Length == rule.DynamicRouteKyes.Length) //若通过动态路径段多寡也无法区分
.Where(r => !SimpleRouteRule.Mutex(r, rule)) //若与现存规则不互斥
.FirstOrDefault();
if (conflictRule != null)
{
return(conflictRule);
}
}
//验证 GetRouteData 时可能的冲突
{
var conflictRule = _rules
.Where(r => r.Paragraphes.Length == rule.Paragraphes.Length) //若路径段长度一致
.Where(r => r.StaticPrefix.EqualsIgnoreCase(rule.StaticPrefix)) //若静态段也一致
.FirstOrDefault();
if (conflictRule != null)
{
return(conflictRule);
}
}
return(null);
}
/// <summary>
/// 添加一个路由规则
/// </summary>
/// <param name="rule">路由规则</param>
protected virtual SimpleRouteRule AddRule(SimpleRouteRule rule)
{
lock ( Routes )
{
if (Routes != null && !Routes.Contains(this))
{
Routes = null;
}
if (Routes == null)
{
throw new InvalidOperationException("简单路由表实例并未被正确的注册在一个路由集合中，无法检测与路由集合中其他简单路由表是否存在冲突，所以不能添加简单路由规则");
}
var conflictRule = Routes.CheckConflict(rule);
if (conflictRule != null)
{
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="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>
/// <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="routes">路由集合</param>
/// <param name="rule">要检查的简单路由规则</param>
/// <returns>如果有冲突，返回冲突的规则</returns>
public static SimpleRouteRule CheckConflict(this RouteCollection routes, SimpleRouteRule rule)
{
if (routes == null)
{
throw new ArgumentNullException("routes");
}
if (rule == null)
{
throw new ArgumentNullException("rule");
}
lock ( routes )
{
return(routes.OfType <SimpleRouteTable>().Select(routeTable => routeTable.CheckConflict(rule)).NotNull().FirstOrDefault());
}
}
