namespace System.Web.Mvc
{
    
    public static class RouteCollectionExtensions
    {
        public static Route MapRoute(this RouteCollection routes, string name, string url)
        {
            return routes.MapRoute(name, url, null, null);
        }

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults)
        {
            return routes.MapRoute(name, url, defaults, null);
        }
    
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints)
        {
            return routes.MapRoute(name, url, defaults, constraints, null);
        }
        
        public static Route MapRoute(this RouteCollection routes, string name, string url, string[] namespaces)
        {
            return routes.MapRoute(name, url, null, null, namespaces);
        }
        
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, string[] namespaces)
        {
            return routes.MapRoute(name, url, defaults, null, namespaces);
        }
        
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (url == null)
            {
                throw new ArgumentNullException("url");
            }
            Route route = new Route(url, new MvcRouteHandler())
            {
                Defaults = new RouteValueDictionary(defaults),
                Constraints = new RouteValueDictionary(constraints),
                DataTokens = new RouteValueDictionary()
            };
            if (namespaces != null && namespaces.Length > 0)
            {
                route.DataTokens["Namespaces"] = namespaces;
            }
            routes.Add(name, route);
            return route;
        }
    }
}

namespace MvcExtension.Models
{

    public static class MyRouteCollectionExtensions
    {
        /// <summary>
        /// 自定义MapRoute方法
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="routeHandler"></param>
        /// <param name="name"></param>
        /// <param name="url"></param>
        /// <param name="defaults"></param>
        /// <param name="constraints"></param>
        /// <param name="namespaces"></param>
        /// <returns></returns>
        public static Route MyMapRoute(this RouteCollection routes, IRouteHandler routeHandler, string name, string url,
            object defaults, object constraints, string[] namespaces)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (url == null)
            {
                throw new ArgumentNullException("url");
            }
            if (routeHandler == null)
            {
                throw new ArgumentNullException("routeHandler");
            }
            Route route = new Route(url, routeHandler)
            {
                Defaults = new RouteValueDictionary(defaults),
                Constraints = new RouteValueDictionary(constraints),
                DataTokens = new RouteValueDictionary()
            };
            if (namespaces != null && namespaces.Length > 0)
            {
                route.DataTokens["Namespaces"] = namespaces;
            }
            routes.Add(name, route);
            return route;
        }

        /// <summary>
        /// 自定义MapRoute方法
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="name"></param>
        /// <param name="route"></param>
        /// <returns></returns>
        public static Route MyMapRoute(this RouteCollection routes, string name, Route route)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (route == null)
            {
                throw new ArgumentNullException("route");
            }
            routes.Add(name, route);
            return route;
        }
    }
}

namespace System.Web.Mvc
{
    public class MvcRouteHandler : IRouteHandler
    {
        private IControllerFactory _controllerFactory;
        public MvcRouteHandler()
        {
        }
        public MvcRouteHandler(IControllerFactory controllerFactory)
        {
            this._controllerFactory = controllerFactory;
        }
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            requestContext.HttpContext.SetSessionStateBehavior(this.GetSessionStateBehavior(requestContext));
            return new MvcHandler(requestContext);
        }
        protected virtual SessionStateBehavior GetSessionStateBehavior(RequestContext requestContext)
        {
            string controllerName = (string)requestContext.RouteData.Values["controller"];
            IControllerFactory controllerFactory = this._controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();
            return controllerFactory.GetControllerSessionBehavior(requestContext, controllerName);
        }
        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
        {
            return this.GetHttpHandler(requestContext);
        }
    }
}

public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
{

    internal ControllerBuilder ControllerBuilder
    {
        get
        {
            if (this._controllerBuilder == null)
            {
                this._controllerBuilder = ControllerBuilder.Current;
            }
            return this._controllerBuilder;
        }
        set
        {
            this._controllerBuilder = value;
        }
    }

    protected virtual void ProcessRequest(HttpContext httpContext)
    {
        HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
        this.ProcessRequest(httpContext2);
    }
    
    protected internal virtual void ProcessRequest(HttpContextBase httpContext)
    {
        SecurityUtil.ProcessInApplicationTrust(delegate
        {
            IController controller;
            IControllerFactory controllerFactory;
            this.ProcessRequestInit(httpContext, out controller, out controllerFactory);
            try
            {
                controller.Execute(this.RequestContext);
            }
            finally
            {
                controllerFactory.ReleaseController(controller);
            }
        });
    }
    private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
    {
        if (ValidationUtility.IsValidationEnabled(HttpContext.Current) == true)
        {
            ValidationUtility.EnableDynamicValidation(HttpContext.Current);
        }
        this.AddVersionHeader(httpContext);
        this.RemoveOptionalRoutingParameters();
        string requiredString = this.RequestContext.RouteData.GetRequiredString("controller");
        //获取ControllerFactory
        factory = this.ControllerBuilder.GetControllerFactory();
        controller = factory.CreateController(this.RequestContext, requiredString);
        if (controller == null)
        {
            throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBuilder_FactoryReturnedNull, new object[]
            {
                factory.GetType(),
                requiredString
            }));
        }
    }
}

public class ControllerBuilder
{
    private Func<IControllerFactory> _factoryThunk = () => null;
    //静态变量，自己创建本身对象
    private static ControllerBuilder _instance = new ControllerBuilder();
    private HashSet<string> _namespaces = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
    private IResolver<IControllerFactory> _serviceResolver;

    //Current
    public static ControllerBuilder Current
    {
        get
        {
            return ControllerBuilder._instance;
        }
    }

    public HashSet<string> DefaultNamespaces
    {
        get
        {
            return this._namespaces;
        }
    }

    public ControllerBuilder() : this(null)
    {
    }

    internal ControllerBuilder(IResolver<IControllerFactory> serviceResolver)
    {
        IResolver<IControllerFactory> arg_6A_1 = serviceResolver;
        if (serviceResolver == null)
        {
            //默认情况下，_serviceResolver赋值为new DefaultControllerFactory
            arg_6A_1 = new SingleServiceResolver<IControllerFactory>(() => this._factoryThunk(), new DefaultControllerFactory
            {
                ControllerBuilder = this
            }, "ControllerBuilder.GetControllerFactory");
        }
        this._serviceResolver = arg_6A_1;
    }

    public IControllerFactory GetControllerFactory()
    {
        //_serviceResolver.Current得到的是DefaultControllerFactory对象，在构造函数中赋值
        return this._serviceResolver.Current;
    }

    public void SetControllerFactory(IControllerFactory controllerFactory)
    {
        if (controllerFactory == null)
        {
            throw new ArgumentNullException("controllerFactory");
        }
        this._factoryThunk = (() => controllerFactory);
    }

    public void SetControllerFactory(Type controllerFactoryType)
    {
        if (controllerFactoryType == null)
        {
            throw new ArgumentNullException("controllerFactoryType");
        }
        if (!typeof(IControllerFactory).IsAssignableFrom(controllerFactoryType))
        {
            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBuilder_MissingIControllerFactory, new object[]
            {
                controllerFactoryType
            }), "controllerFactoryType");
        }
        this._factoryThunk = delegate
        {
            IControllerFactory result;
            try
            {
                result = (IControllerFactory)Activator.CreateInstance(controllerFactoryType);
            }
            catch (Exception innerException)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBuilder_ErrorCreatingControllerFactory, new object[]
                {
                    controllerFactoryType
                }), innerException);
            }
            return result;
        };
    }
}

private class DefaultControllerActivator : IControllerActivator
{
    private Func<IDependencyResolver> _resolverThunk;
    public DefaultControllerActivator() : this(null)
    {
    }
    public DefaultControllerActivator(IDependencyResolver resolver)
    {
        if (resolver == null)
        {
            this._resolverThunk = (() => DependencyResolver.Current);
            return;
        }
        this._resolverThunk = (() => resolver);
    }
    public IController Create(RequestContext requestContext, Type controllerType)
    {
        IController result;
        try
        {
            result = (IController)(this._resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
        }
        catch (Exception innerException)
        {
            throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ErrorCreatingController, new object[]
            {
                controllerType
            }), innerException);
        }
        return result;
    }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public sealed class ActionNameAttribute : ActionNameSelectorAttribute
{
    public string Name
    {
        get;
        private set;
    }

    public ActionNameAttribute(string name)
    {
        if (string.IsNullOrEmpty(name))
        {
            throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
        }
        this.Name = name;
    }

    public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
    {
        return string.Equals(actionName, this.Name, StringComparison.OrdinalIgnoreCase);
    }
}

using System;
namespace System.Web.Mvc
{
    /// <summary>Represents an attribute that is used to indicate that an action method should be called only as a child action.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class ChildActionOnlyAttribute : FilterAttribute, IAuthorizationFilter
    {
        /// <summary>Called when authorization is required.</summary>
        /// <param name="filterContext">An object that encapsulates the information that is required in order to authorize access to the child action.</param>
        public void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }
            if (!filterContext.IsChildAction)
            {
                throw Error.ChildActionOnlyAttribute_MustBeInChildRequest(filterContext.ActionDescriptor);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Principal;
using System.Web.Mvc.Resources;
namespace System.Web.Mvc
{
    /// <summary>Represents an attribute that is used to restrict access by callers to an action method.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public class AuthorizeAttribute : FilterAttribute, IAuthorizationFilter
    {
        private readonly object _typeId = new object();
        private string _roles;
        private string[] _rolesSplit = new string[0];
        private string _users;
        private string[] _usersSplit = new string[0];
        /// <summary>Gets or sets the user roles.</summary>
        /// <returns>The user roles.</returns>
        public string Roles
        {
            get
            {
                return this._roles ?? string.Empty;
            }
            set
            {
                this._roles = value;
                this._rolesSplit = AuthorizeAttribute.SplitString(value);
            }
        }
        /// <summary>Gets the unique identifier for this attribute.</summary>
        /// <returns>The unique identifier for this attribute.</returns>
        public override object TypeId
        {
            get
            {
                return this._typeId;
            }
        }
        /// <summary>Gets or sets the authorized users.</summary>
        /// <returns>The authorized users.</returns>
        public string Users
        {
            get
            {
                return this._users ?? string.Empty;
            }
            set
            {
                this._users = value;
                this._usersSplit = AuthorizeAttribute.SplitString(value);
            }
        }
        /// <summary>When overridden, provides an entry point for custom authorization checks.</summary>
        /// <returns>true if the user is authorized; otherwise, false.</returns>
        /// <param name="httpContext">The HTTP context, which encapsulates all HTTP-specific information about an individual HTTP request.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="httpContext" /> parameter is null.</exception>
        protected virtual bool AuthorizeCore(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            IPrincipal user = httpContext.User;
            return user.Identity.IsAuthenticated && (this._usersSplit.Length <= 0 || this._usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase)) && (this._rolesSplit.Length <= 0 || this._rolesSplit.Any(new Func<string, bool>(user.IsInRole)));
        }
        private void CacheValidateHandler(HttpContext context, object data, ref HttpValidationStatus validationStatus)
        {
            validationStatus = this.OnCacheAuthorization(new HttpContextWrapper(context));
        }
        /// <summary>Called when a process requests authorization.</summary>
        /// <param name="filterContext">The filter context, which encapsulates information for using <see cref="T:System.Web.Mvc.AuthorizeAttribute" />.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="filterContext" /> parameter is null.</exception>
        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }
            if (OutputCacheAttribute.IsChildActionCacheActive(filterContext))
            {
                throw new InvalidOperationException(MvcResources.AuthorizeAttribute_CannotUseWithinChildActionCache);
            }
            if (this.AuthorizeCore(filterContext.HttpContext))
            {
                HttpCachePolicyBase cache = filterContext.HttpContext.Response.Cache;
                cache.SetProxyMaxAge(new TimeSpan(0L));
                cache.AddValidationCallback(new HttpCacheValidateHandler(this.CacheValidateHandler), null);
                return;
            }
            this.HandleUnauthorizedRequest(filterContext);
        }
        /// <summary>Processes HTTP requests that fail authorization.</summary>
        /// <param name="filterContext">Encapsulates the information for using <see cref="T:System.Web.Mvc.AuthorizeAttribute" />. The <paramref name="filterContext" /> object contains the controller, HTTP context, request context, action result, and route data.</param>
        protected virtual void HandleUnauthorizedRequest(AuthorizationContext filterContext)
        {
            filterContext.Result = new HttpUnauthorizedResult();
        }
        /// <summary>Called when the caching module requests authorization.</summary>
        /// <returns>A reference to the validation status.</returns>
        /// <param name="httpContext">The HTTP context, which encapsulates all HTTP-specific information about an individual HTTP request.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="httpContext" /> parameter is null.</exception>
        protected virtual HttpValidationStatus OnCacheAuthorization(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            if (!this.AuthorizeCore(httpContext))
            {
                return HttpValidationStatus.IgnoreThisRequest;
            }
            return HttpValidationStatus.Valid;
        }
        internal static string[] SplitString(string original)
        {
            if (string.IsNullOrEmpty(original))
            {
                return new string[0];
            }
            IEnumerable<string> source = 
                from piece in original.Split(new char[]
                {
                    ‘,‘
                })
                let trimmed = piece.Trim()
                where !string.IsNullOrEmpty(trimmed)
                select trimmed;
            return source.ToArray<string>();
        }
    }
}