System.Web.Routing命名空间代码解析（一） RouteBase类,RouteData类,RouteValueDictionary类

1.RouteBase是一个抽象基类，定义了两个功能：

1.从HttpContextBase中根据Route Map规则得到RouteData

2.得到虚拟路径数据(将在 Route 类(下) 中讲解)

using  System.Security.Permissions;
using  System.Web;

namespace  System.Web.Routing
{
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal),
     AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    public abstract class RouteBase
    {
        // Methods

        public abstract RouteData GetRouteData(HttpContextBase httpContext);
        public abstract VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
    }
}

 

2. RouteData类，保存Route数据的类，提供如下功能

     1.可保存对Route和RouteHandler的引用（基类和接口）

     2.保存两个键值对，分别存储RouteValues 和用户自传入的DataToken

     3.提供一个方法从RouteValues 中读取文本值

using  System;
using  System.Globalization;
using  System.Security.Permissions;
using  System.Web;

namespace  System.Web.Routing
{
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal),
     AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    public class RouteData
    {
        // Fields
        private RouteValueDictionary _dataTokens;
        private IRouteHandler _routeHandler;
        private RouteValueDictionary _values;

        // Methods
        public RouteData()
        {
            this._values = new RouteValueDictionary();
            this._dataTokens = new RouteValueDictionary();
        }

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

        public string GetRequiredString(string valueName)
        {
            object obj2;
            if (this.Values.TryGetValue(valueName, out obj2))
            {
                string str = obj2 as string;
                if (!string.IsNullOrEmpty(str))
                    return str;
            }
            throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture,
                                                              RoutingResources.RouteData_RequiredValue,
                                                              new object[] {valueName}));
        }

        // Properties
        public RouteValueDictionary DataTokens
        {
            get { return this._dataTokens; }
        }

        public RouteBase Route { get; set; }

        public IRouteHandler RouteHandler
        {
            get { return this._routeHandler; }
            set { this._routeHandler = value; }
        }

        public RouteValueDictionary Values
        {
            get { return this._values; }
        }
    }
}

 

3.RouteValueDictionary 类，实现了一个IDictionary<string, object>接口，包装了一个Dictionary<string, object>对象，其实没什么功能的，唯一的功能就是支持传入一个对象（最好是匿名类型的对象），并通过反射把它当作键值对使用，详情请看代码中加粗的部分。

 

using  System;
using  System.Collections;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Linq;
using  System.Security.Permissions;
using  System.Web;

namespace  System.Web.Routing
{
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal),
     AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    public class RouteValueDictionary : IDictionary<string, object>
    {
        // Fields
        private Dictionary<string, object> _dictionary;

        Constructors#region Constructors

        public RouteValueDictionary()
        {
            this._dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }

        public RouteValueDictionary(IDictionary<string, object> dictionary)
        {
            this._dictionary = new Dictionary<string, object>(dictionary, StringComparer.OrdinalIgnoreCase);
        }

        public RouteValueDictionary(object values)
        {
            this._dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            this.AddValues(values);
        }

        #endregion

        private void AddValues(object values)
        {
            if (values != null)
                foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(values))
                {
                    object obj2 = descriptor.GetValue(values);
                    this.Add(descriptor.Name, obj2);
                }
        }

        public bool ContainsValue(object value)
        {
            return this._dictionary.ContainsValue(value);
        }

        public Dictionary<string, object>.Enumerator GetEnumerator()
        {
            return this._dictionary.GetEnumerator();
        }

        public Dictionary<string, object>.KeyCollection Keys
        {
            get { return this._dictionary.Keys; }
        }

        public Dictionary<string, object>.ValueCollection Values
        {
            get { return this._dictionary.Values; }
        }

        IEnumerableKeyValuePairstring, object Members#region IEnumerable<KeyValuePair<string, object>> Members

        IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

        IEnumerable Members#region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

        Implementation of ICollectionKeyValuePairstring,object#region Implementation of ICollection<KeyValuePair<string,object>>

        public void Add(KeyValuePair<string, object> item)
        {
            ((ICollection<KeyValuePair<string, object>>) this._dictionary).Add(item);
        }

        public bool Contains(KeyValuePair<string, object> item)
        {
            return this._dictionary.Contains(item);
        }

        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            ((ICollection<KeyValuePair<string, object>>) this._dictionary).CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<string, object> item)
        {
            return ((ICollection<KeyValuePair<string, object>>) this._dictionary).Remove(item);
        }

        public void Clear()
        {
            this._dictionary.Clear();
        }

        public int Count
        {
            get { return this._dictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return ((ICollection<KeyValuePair<string, object>>) this._dictionary).IsReadOnly; }
        }

        #endregion

        Implementation of IDictionarystring,object#region Implementation of IDictionary<string,object>

        public void Add(string key, object value)
        {
            this._dictionary.Add(key, value);
        }

        public bool ContainsKey(string key)
        {
            return this._dictionary.ContainsKey(key);
        }

        public bool Remove(string key)
        {
            return this._dictionary.Remove(key);
        }

        public bool TryGetValue(string key, out object value)
        {
            return this._dictionary.TryGetValue(key, out value);
        }

        IDictionarystring,object Members#region IDictionary<string,object> Members

        ICollection<string> IDictionary<string, object>.Keys
        {
            get { return this.Keys; }
        }

        ICollection<object> IDictionary<string, object>.Values
        {
            get { return this.Values; }
        }

        #endregion

        public object this[string key]
        {
            get
            {
                object obj2;
                this.TryGetValue(key, out obj2);
                return obj2;
            }
            set { this._dictionary[key] = value; }
        }

        #endregion
    }
}