MVC的控制器的激活过程，我们从MvcHandler开始讲，前面的事情以后再讲

using Microsoft.Web.Infrastructure.DynamicValidationHelper;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.SessionState;
namespace System.Web.Mvc
{
    /// 
Selects the controller that will handle an HTTP request.
    public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
    {
        private static readonly object _processRequestTag = new object();
        internal static readonly string MvcVersion = MvcHandler.GetMvcVersionString();
        /// 
Contains the header name of the ASP.NET MVC version.
        public static readonly string MvcVersionHeaderName = "X-AspNetMvc-Version";
        private ControllerBuilder _controllerBuilder;
        internal ControllerBuilder ControllerBuilder
        {
            get
            {
                if (this._controllerBuilder == null)
                {
                    this._controllerBuilder = ControllerBuilder.Current;
                }
                return this._controllerBuilder;
            }
            set
            {
                this._controllerBuilder = value;
            }
        }
        /// 
Gets or sets a value that indicates whether the MVC response header is disabled.
        /// true if the MVC response header is disabled; otherwise, false.
        public static bool DisableMvcResponseHeader
        {
            get;
            set;
        }
        /// 
Gets a value that indicates whether another request can use the  instance.
        /// true if the  instance is reusable; otherwise, false.
        protected virtual bool IsReusable
        {
            get
            {
                return false;
            }
        }
        /// 
Gets the request context.
        /// The request context.
        public RequestContext RequestContext
        {
            get;
            private set;
        }
        /// 
Gets a value that indicates whether another request can use the  instance.
        /// true if the  instance is reusable; otherwise, false.
        bool IHttpHandler.IsReusable
        {
            get
            {
                return this.IsReusable;
            }
        }
        /// 
Initializes a new instance of the  class.
        /// The request context.
        /// The  parameter is null.
        public MvcHandler(RequestContext requestContext)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            this.RequestContext = requestContext;
        }
        /// 
Adds the version header by using the specified HTTP context.
        /// The HTTP context.
        protected internal virtual void AddVersionHeader(HttpContextBase httpContext)
        {
            if (!MvcHandler.DisableMvcResponseHeader)
            {
                httpContext.Response.AppendHeader(MvcHandler.MvcVersionHeaderName, MvcHandler.MvcVersion);
            }
        }
        /// 
Called by ASP.NET to begin asynchronous request processing.
        /// The status of the asynchronous call.
        /// The HTTP context.
        /// The asynchronous callback method.
        /// The state of the asynchronous object.
        protected virtual IAsyncResult BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, object state)
        {
            HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
            return this.BeginProcessRequest(httpContext2, callback, state);
        }
        /// 
Called by ASP.NET to begin asynchronous request processing using the base HTTP context.
        /// The status of the asynchronous call.
        /// The HTTP context.
        /// The asynchronous callback method.
        /// The state of the asynchronous object.
        protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
        {
            IController controller;
            IControllerFactory factory;
            this.ProcessRequestInit(httpContext, out controller, out factory);
            IAsyncController asyncController = controller as IAsyncController;
            if (asyncController != null)
            {
                BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
                {
                    IAsyncResult result;
                    try
                    {
                        result = asyncController.BeginExecute(this.RequestContext, asyncCallback, asyncState);
                    }
                    catch
                    {
                        factory.ReleaseController(asyncController);
                        throw;
                    }
                    return result;
                };
                EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult)
                {
                    try
                    {
                        asyncController.EndExecute(asyncResult);
                    }
                    finally
                    {
                        factory.ReleaseController(asyncController);
                    }
                };
                SynchronizationContext synchronizationContext = SynchronizationContextUtil.GetSynchronizationContext();
                AsyncCallback callback2 = AsyncUtil.WrapCallbackForSynchronizedExecution(callback, synchronizationContext);
                return AsyncResultWrapper.Begin(callback2, state, beginDelegate, endDelegate, MvcHandler._processRequestTag);
            }
            Action action = delegate
            {
                try
                {
                    controller.Execute(this.RequestContext);
                }
                finally
                {
                    factory.ReleaseController(controller);
                }
            };
            return AsyncResultWrapper.BeginSynchronous(callback, state, action, MvcHandler._processRequestTag);
        }
        /// 
Called by ASP.NET when asynchronous request processing has ended.
        /// The asynchronous result.
        protected internal virtual void EndProcessRequest(IAsyncResult asyncResult)
        {
            AsyncResultWrapper.End(asyncResult, MvcHandler._processRequestTag);
        }
        private static string GetMvcVersionString()
        {
            return new AssemblyName(typeof(MvcHandler).Assembly.FullName).Version.ToString(2);
        }
        /// 
Processes the request by using the specified HTTP request context.
        /// The HTTP context.
        protected virtual void ProcessRequest(HttpContext httpContext)
        {
            HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
            this.ProcessRequest(httpContext2);
        }
        /// 
Processes the request by using the specified base HTTP request context.
        /// The HTTP context.
        protected internal virtual void ProcessRequest(HttpContextBase httpContext)
        {
            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)
        {
            HttpContext current = HttpContext.Current;
            if (current != null && ValidationUtility.IsValidationEnabled(current) == true)
            {
                ValidationUtility.EnableDynamicValidation(current);
            }
            this.AddVersionHeader(httpContext);
            this.RemoveOptionalRoutingParameters();
            string requiredString = this.RequestContext.RouteData.GetRequiredString("controller");
            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
                }));
            }
        }
        private void RemoveOptionalRoutingParameters()
        {
            RouteValueDictionary values = this.RequestContext.RouteData.Values;
            string[] array = (
                from entry in values
                where entry.Value == UrlParameter.Optional
                select entry.Key).ToArraystring>();
            string[] array2 = array;
            for (int i = 0; i )
            {
                string key = array2[i];
                values.Remove(key);
            }
        }
        /// 
Enables processing of HTTP Web requests by a custom HTTP handler that implements the  interface.
        /// An  object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) that are used to service HTTP requests.
        void IHttpHandler.ProcessRequest(HttpContext httpContext)
        {
            this.ProcessRequest(httpContext);
        }
        /// 
Called by ASP.NET to begin asynchronous request processing using the base HTTP context.
        /// The status of the asynchronous call.
        /// The HTTP context.
        /// The asynchronous callback method.
        /// The data.
        IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            return this.BeginProcessRequest(context, cb, extraData);
        }
        /// 
Called by ASP.NET when asynchronous request processing has ended.
        /// The asynchronous result.
        void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result)
        {
            this.EndProcessRequest(result);
        }
    }
}

private sealed class CacheDependencyResolver : IDependencyResolver
        {
            private readonly ConcurrentDictionaryobject> _cache = new ConcurrentDictionaryobject>();
            private readonly ConcurrentDictionaryobject>> _cacheMultiple = new ConcurrentDictionaryobject>>();
            private readonly IDependencyResolver _resolver;
            public CacheDependencyResolver(IDependencyResolver resolver)
            {
                this._resolver = resolver;
            }
            public object GetService(Type serviceType)
            {
                return this._cache.GetOrAdd(serviceType, new Funcobject>(this._resolver.GetService));
            }
            public IEnumerableobject> GetServices(Type serviceType)
            {
                return this._cacheMultiple.GetOrAdd(serviceType, new Funcobject>>(this._resolver.GetServices));
            }