白話學習MVC(七)Action的執行一

時間  2019-11-10
標籤 白話 學習 mvc action 執行 简体版
原文   原文鏈接

1、概述

　　在此係列開篇的時候介紹了MVC的生命週期 ， 對於請求的處理，都是將相應的類的方法註冊到HttpApplication事件中，經過事件的依次執行從而完成對請求的處理。對於MVC來講，請求是先 通過路由系統，而後由一個MvcHandler來處理的，當請求到來時，執行此MvcHandler的ProcessRequest方法（由於已將 MvcHandler類的ProcessRequest方法註冊到HttpApplication的事件中，因此事件的執行就觸發了此方法）。詳細請看以前介紹MVC生命週期的兩篇博客。
　　下面咱們就以MVC聲明週期爲主線，來分析下MVC源碼
html

public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
{
    protected virtual void ProcessRequest(HttpContext httpContext)
    {
        //使用HttpContextWrapper對HttpContext進行封裝,封裝的目的是爲了解耦以得到可測試性.而後從RequestContext.RouteData中提取Controller名稱.
        HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
        this.ProcessRequest(httpContext2);
    }
    
    protected internal virtual void ProcessRequest(HttpContextBase httpContext)
    {
        IController controller;
        IControllerFactory controllerFactory;
        this.ProcessRequestInit(httpContext, out controller, out controllerFactory);//獲取到Controler和ControllerFactory實例，並賦值給局部變量
        try
        {
　　　　　　　　　 //Action的調用、View的呈現
                controller.Execute(this.RequestContext);
                
        }
        finally
        {
            //釋放當前Controler對象
            controllerFactory.ReleaseController(controller); 
        }
    }
}

　　MVC中Action的調用，就是經過調用Contrller對象的Execute方法觸發執行的！這個Controller對象是Controller激活的產物，Controller激活請參考上一篇博客。數組

2、Action的調用

　　咱們知道Action的執行就是調用經過Controller激活獲得的Controller對象的Execute方法，這個Controller對象就是咱們建立的Controller（例如：HomeController）類的實例，而咱們建立的HomeController等控制器都繼承自Controller類、Controller抽象類繼承ControllerBase抽象類、ControllerBase抽象類實現了IController接口。繼承和實現關係爲：
緩存

　　咱們建立的控制器經過Controller的激活建立了實例，而後執行該實例的Execute方法，Execute方法定義在接口IController中，實如今類ControllerBase中，而該Excute方法內又調用ControllerBase類的抽象方法ExecuteCore，抽象方法ExecuteCore又在Controller類中實現。因此Action調用的流程爲：先執行ControllerBase類的Execute方法，再執行Controller類的ExcuteCore方法。因此執行過程爲：【ControllerBase類中的Execute方法】-->【Controller類中的ExecuteCore方法】服務器

namespace System.Web.Mvc
{
    public interface IController
    {
        void Execute(RequestContext requestContext);
    }
}
IController 
namespace System.Web.Mvc
{
    public abstract class ControllerBase : IController
    {    
        //省略其餘成員
        
        protected virtual void Execute(RequestContext requestContext)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (requestContext.HttpContext == null)
            {
                throw new ArgumentException(MvcResources.ControllerBase_CannotExecuteWithNullHttpContext, "requestContext");
            }

            VerifyExecuteCalledOnce();
            Initialize(requestContext);

            using (ScopeStorage.CreateTransientScope())
            {
                //執行ExecuteCore方法
                ExecuteCore();
            }
        }
        //該方法在派生類Controller類中實現
        protected abstract void ExecuteCore();
    }
}
ControllerBase 
namespace System.Web.Mvc
{
    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        //省略其餘成員
        
        //實現ControllerBase中的抽象方法
        protected override void ExecuteCore()
        {
            // If code in this method needs to be updated, please also check the BeginExecuteCore() and
            // EndExecuteCore() methods of AsyncController to see if that code also must be updated.
            PossiblyLoadTempData();
            try
            {
                //從路由中獲取Action的名字
                string actionName = RouteData.GetRequiredString("action");
                //根據Action名字和上下文對Action進行調用
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                PossiblySaveTempData();
            }
        }
    }
}
Controller

　　由上述代碼能夠看出Action的執行最終實如今Controller類的ExecuteCore方法中，而其中ActionInvoker就是實現Action調用的組件，執行ActionInvoker的InvokeAction方法實現對Action的調用。session

整個執行過程的功能爲：【檢查對請求只作一次處理】-->【封裝請求上下文】-->【獲取上一次沒有被使用的TempData】-->【過濾器、Action的執行】-->【View的呈現（下一節介紹）】-->【將沒有被使用的TempData放入Session中】
app

//整個流程
    public abstract class ControllerBase : IController
    {
        protected virtual void Execute(RequestContext requestContext)
        {
            //檢查對請求只作一次處理
            VerifyExecuteCalledOnce();
            //封裝請求上下文(RequestContext對象是在路由系統中建立的。其中封裝了請求上下文和路由信息。)
            Initialize(requestContext);
            //定義用於包含臨時做用域存儲的類。    基於 CurrentScope 屬性中的做用域，返回用於存儲臨時做用域內的數據的字典。
            //這個的做用暫時尚未弄清楚，不過經過重寫Execute方法，在using塊內能夠獲取ScopeStorage的屬性CurrentScope的三個鍵值對。
            using (ScopeStorage.CreateTransientScope())
            {
                //執行Controller類中的ExecuteCore方法
                ExecuteCore();
            }
        }
    }
    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {    
        protected override void ExecuteCore()
        {
            //獲取上一次沒有被使用的TempData
            PossiblyLoadTempData();
            try
            {
                //從路由數據中獲取請求的Action的名字（路由系統從請求地址中獲取）
                string actionName = RouteData.GetRequiredString("action");
                //過濾器、Action的執行、View的呈現
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                //將沒有被使用的TempData放入Session中
                PossiblySaveTempData();
            }
        }
    }

　==從以上的執行過程當中各代碼的功能能夠看出ExecuteCore()方法是Action執行的主操做，而VerifyExecuteCalledOnce()、Initialize(requestContext)兩個方法是前戲了。咱們就先來分析下這兩個前戲的方法，主操做ExecuteCore()方法留着最後，並對其內部操做再進行詳細分析。框架

 一、VerifyExecuteCalledOnce()less

　　此方法保證了一次Http請求只進行一次處理ide

    public abstract class ControllerBase : IController
    {
        private readonly SingleEntryGate _executeWasCalledGate = new SingleEntryGate();

        //RequestContext對象是在路由系統中建立的。其中封裝了請求上下文和路由信息。
        protected virtual void Execute(RequestContext requestContext)
        {
            //判斷對當期的請求是不是第一次執行處理
            VerifyExecuteCalledOnce();
            //執行Controller類的Initialize方法。（Initialize方法在Controller類中被重寫）
            Initialize(requestContext);
            //定義用於包含臨時做用域存儲的類。    基於 CurrentScope 屬性中的做用域，返回用於存儲臨時做用域內的數據的字典。
            //這個的做用暫時尚未弄清楚，不過經過重寫Execute方法，在using塊內能夠獲取ScopeStorage的屬性CurrentScope的三個鍵值對。
            using (ScopeStorage.CreateTransientScope())
            {
                //執行Controller類中的ExecuteCore方法
                ExecuteCore();
            }
        }
        
        internal void VerifyExecuteCalledOnce()
        {
            //若是是TryEnter方法是第一次執行_executeWasCalledGate.TryEnter()=true
            //不然_executeWasCalledGate.TryEnter()=false
            if (!_executeWasCalledGate.TryEnter())
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBase_CannotHandleMultipleRequests, GetType());
                throw new InvalidOperationException(message);
            }
        }
        
    }
ControllerBase 
    internal sealed class SingleEntryGate
    {
        private const int NotEntered = 0;
        private const int Entered = 1;

        private int _status;

        // returns true if this is the first call to TryEnter(), false otherwise
        public bool TryEnter()
        {
            //Interlocked靜態類定義在System.Threading命名空間中且Exchange方法是extern的（定義在別的文件中）！
            //方法的概述爲：以原子操做的形式，將 32 位有符號整數設置爲指定的值並返回原始值。原子操做是指不會被線程調度機制打斷的操做；這種操做一旦開始，就一直運行到結束
            //Interlocked.Exchange方法將Extered的值設置給_status，並返回值爲第一個參數_status的原始值
            int oldStatus = Interlocked.Exchange(ref _status, Entered);
            return (oldStatus == NotEntered);
        }
    }
SingleEntryGate

    ==上述代碼，在ControllerBase類中私有隻讀字段_executeWasCalledGate建立了一個SingleEntryGate對象，而VerifyExecuteCalledOnce方法的功能就是經過 這個對象的TryTryEnter方法來實現的！若是TryTryEnter方法返回值爲：true，則表示是第一次執行；不然非第一次執行，那麼就拋出非法操做異常了。從而保證了一次Http請求只進行一次處理。
而內部究竟是如何實現的呢？咱們就在來看看SingleEntryGate類，其中的TeyEnter方法中調用了Interlocked.Exchange(ref int1,int2)方法，此方法定義的System.Threading命名空間內，方法的功能爲：將第二個參數的值賦值給第一個參數，並將第一個參數原來的值做爲方法的返回值。
例如：
　　若是是第一次調用TryEnter方法【Entered=1，_status=0，NotEntered = 0】執行完Interlocked.Exchange方法後【Entered = 1，_status=1，NotEntered = 0，oldStatus=0】，此時oldStatus=NotEntered = 0，返回true
　　若是是第n次調用TryEnter方法，那麼此時的變量值仍是第一次執行完的狀態【Entered = 1，_status=1，NotEntered = 0】，而執行完Interlocked.Exchange方法後【Entered = 1，_status=1，NotEntered = 0，oldStatus=1】，此時NotEntered = 0，oldStatus=1，不相等，返回false函數

注意，在ControllerBase類中私有隻讀字段_executeWasCalledGate是非靜態的字段，因此實現的功能是【檢查每一次請求只執行一次】，若是是靜態字段，那麼就變成了程序只執行一次請求的處理。（這功能的實現值得收藏）

二、Initialize(requestContext)

　　將 requestContext 和 當前請求的控制對象 封裝到一個 ControllerContext對象中！其中requestContext是已封裝了請求上下文和當前請求的路由信息的一個上下文。

    public abstract class ControllerBase : IController
    {
        public ControllerContext ControllerContext { get; set; }
        
        //RequestContext對象是在路由系統中建立的。其中封裝了請求上下文和路由信息。
        protected virtual void Execute(RequestContext requestContext)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (requestContext.HttpContext == null)
            {
                throw new ArgumentException(MvcResources.ControllerBase_CannotExecuteWithNullHttpContext, "requestContext");
            }
            //判斷是否爲第一次執行
            VerifyExecuteCalledOnce();
            //執行Controller類的Initialize方法。（Initialize方法在Controller類中被重寫）
            Initialize(requestContext);
            //定義用於包含臨時做用域存儲的類。    基於 CurrentScope 屬性中的做用域，返回用於存儲臨時做用域內的數據的字典。
            //這個的做用暫時尚未弄清楚，不過經過重寫Execute方法，在using塊內能夠獲取ScopeStorage的屬性CurrentScope的三個鍵值對。
            using (ScopeStorage.CreateTransientScope())
            {
                //執行Controller類中的ExecuteCore方法
                ExecuteCore();
            }
        }
        protected virtual void Initialize(RequestContext requestContext)
        {
            ControllerContext = new ControllerContext(requestContext, this);
        }        
    }
ControllerBase 
    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        public UrlHelper Url { get; set; }
        
        protected override void Initialize(RequestContext requestContext)
        {
            base.Initialize(requestContext);
            Url = new UrlHelper(requestContext);
        }
    }
Controller 
    public class ControllerContext
    {
        internal const string ParentActionViewContextToken = "ParentActionViewContext";
        private HttpContextBase _httpContext;
        private RequestContext _requestContext;
        private RouteData _routeData;

        // parameterless constructor used for mocking
        public ControllerContext()
        {
        }
        protected ControllerContext(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Controller = controllerContext.Controller;
            RequestContext = controllerContext.RequestContext;
        }

        public ControllerContext(HttpContextBase httpContext, RouteData routeData, ControllerBase controller)
            : this(new RequestContext(httpContext, routeData), controller)
        {
        }

        //【Action的執行】過程當中，經過請求上下文和請求的當期控制器對象（如：HomeController）建立控制器上下文。
        public ControllerContext(RequestContext requestContext, ControllerBase controller)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (controller == null)
            {
                throw new ArgumentNullException("controller");
            }
            RequestContext = requestContext;//上下文參數設置給私有變量
            Controller = controller;        //控制器（如：HomeController）對象設置給屬性
        }

        public virtual ControllerBase Controller { get; set; }

        public IDisplayMode DisplayMode
        {
            get { return DisplayModeProvider.GetDisplayMode(HttpContext); }
            set { DisplayModeProvider.SetDisplayMode(HttpContext, value); }
        }

        public virtual HttpContextBase HttpContext
        {
            get
            {
                if (_httpContext == null)
                {
                    _httpContext = (_requestContext != null) ? _requestContext.HttpContext : new EmptyHttpContext();
                }
                return _httpContext;
            }
            set { _httpContext = value; }
        }

        public virtual bool IsChildAction
        {
            get
            {
                RouteData routeData = RouteData;
                if (routeData == null)
                {
                    return false;
                }
                return routeData.DataTokens.ContainsKey(ParentActionViewContextToken);
            }
        }

        public ViewContext ParentActionViewContext
        {
            get { return RouteData.DataTokens[ParentActionViewContextToken] as ViewContext; }
        }

        public RequestContext RequestContext
        {
            get
            {
                if (_requestContext == null)
                {
                    // still need explicit calls to constructors since the property getters are virtual and might return null
                    HttpContextBase httpContext = HttpContext ?? new EmptyHttpContext();
                    RouteData routeData = RouteData ?? new RouteData();

                    _requestContext = new RequestContext(httpContext, routeData);
                }
                return _requestContext;
            }
            set { _requestContext = value; }
        }

        public virtual RouteData RouteData
        {
            get
            {
                if (_routeData == null)
                {
                    _routeData = (_requestContext != null) ? _requestContext.RouteData : new RouteData();
                }
                return _routeData;
            }
            set { _routeData = value; }
        }

        private sealed class EmptyHttpContext : HttpContextBase
        {
        }
    }
ControllerContext

    ==上述代碼，對於Initialize方法的執行，因爲ControllerBase中的Initialize方法在派生類Controller類中被重寫，因此要執行Controller類中的Initialize方法。方法內首先調用了父類ControllerBase中的Initialize方法建立了一個控制器上下文對象，並賦值給一個公有屬性。以後又建立了UrlHelper對象也賦值給了一個公有屬性。這個控制器上下文對象包含了從請求到如今的全部有用的數據，因此在以後對請求處理的步驟中隨處可見！這個UrlHelper對象還沒用到，暫且不議。

三、ExecuteCore()

　　ControllerBase類中定義了抽象方法ExecuteCore，該方法被派生類Controller類中實現！因此，要執行Controller類中的ExecuteCore方法，如上所言，此方法是Action執行的主操做，其中先對上一次操做沒有被TempData作處理，而後執行過濾器和請求的Action，最後進行View的呈現（下一節再對View的呈現作分析，如今只需知道這個執行的流程便可）。下面，咱們就來用分析全部過程的代碼！

    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        protected override void ExecuteCore()
        {
            //獲取上次處理過程當中沒有被使用的TempData
            PossiblyLoadTempData();
            try
            {
                //從路由數據中獲取請求的Action的名字
                string actionName = RouteData.GetRequiredString("action");
                //ActionInvoker爲一個AsyncControllerActionInvoker對象
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                //將TempData保存到Session中。等待以後將Session的key【__ControllerTempData】發送到響應流中！
 PossiblySaveTempData();
            }
        }
    }

3-一、PossiblyLoadTempData()

　　此方法建立保存TempData的集合並獲取上一次請求中沒有被使用TempData添加到以前建立的那個集合中！

在介紹這個方法以前，有必要先了解下MVC框架下TempData的機制：
客戶端向服務發請求時，程序在執行本次請求的Action前，會先建立一個用來保存TempData的集合A，而後根據key=__ControllerTempData去服務器Session中獲取值並轉換爲Dictionary<string, object>類型，若是獲得的值爲null，表示三種狀況（一、當前是客戶端第一次向服務端發送請求。二、上次請求中沒有定義TempData值。三、上次請求中的TempData被View中用完了。）；若是獲得的值不爲null，則表示上一次對請求的處理時TempData沒有被使用完，此時獲取的值就是上次處理請求時沒有被使用的TempData集合，而後將這集合賦值給咱們開始建立的用於保存TempData的集合A中，再將key=__ControllerTempData的Session移除；以後執行Action方法內的代碼時，將本次的請求的Action中定義的TempData[""]=XXX也添加到最開始建立的那個集合A中，執行完Action方法後，在View的呈現中，若是使用了TempData，就將這個TempData從集合A中移除，執行完View後，則將保存TempData的集合A看成value，key=__ControllerTempData保存到服務器Session中。最後將全部Session的keys發送到響應流中！

上述提到那個保存TempData的集合A其實是TempDataDictionary類型中的一個變量，該變量是一個字典類對象（new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)）
TempData是ControllerBase類中的一個類型爲TempDataDictionary的屬性，TempData屬性其實就是一個TempDataDictionary對象，該對象中有一個字典類型的私有字段保存着全部TempData的值！
咱們在Action方法中使用的TempData["kk"]=XX，其實就是調用的TempDataDictionary對象的索引器，將該鍵值對添加到保存全部TempData的私有字典表中！
擴展：Session的機制，Session保存在服務器，可是請求的最後服務端會將Session的全部key發送到響應流中！當再次發來請求時，能夠從請求上下文中獲取到全部的keys。

    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        protected override void ExecuteCore()
        {
            //獲取上次處理過程當中沒有被使用的TempData
            PossiblyLoadTempData();
            try
            {
                //從路由數據中獲取請求的Action的名字
                string actionName = RouteData.GetRequiredString("action");
                //ActionInvoker爲一個AsyncControllerActionInvoker對象
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                //將TempData保存到Session中。等待以後將Session的key【__ControllerTempData】發送到響應流中！
                PossiblySaveTempData();
            }
        }
        
        private ITempDataProvider _tempDataProvider;
        
        internal IDependencyResolver Resolver
        {
            get { return _resolver ?? DependencyResolver.CurrentCache; }
            set { _resolver = value; }
        }
        
        public ITempDataProvider TempDataProvider
        {
            get
            {
                if (_tempDataProvider == null)
                {
                    _tempDataProvider = CreateTempDataProvider();
                }
                return _tempDataProvider;
            }
            set { _tempDataProvider = value; }
        }
        
        protected virtual ITempDataProvider CreateTempDataProvider()
        {
            //Resolver是Controller的一個屬性，返回值爲：DependencyResolver.CurrentCache
            //Resolver.GetService<ITempDataProvider>() 能夠不用看，由於返回的是null。這個方法其實先根據key=ITempDataProvider從全局的緩存表中查找值，若是有值，則返回。若是沒有，則利用DefaultDependencyResolver對象經過反射
            //根據類型ITempDataProvider建立對象。可是因爲這裏的ITempDataProvider是接口，而DefaultDependencyResolver對象反射建立對象時，若是是接口或抽象類均返回null。詳細請看DependencyResolver類！
            //因此這段代碼，返回值就是 new SessionStateTempDataProvider();
            return Resolver.GetService<ITempDataProvider>() ?? new SessionStateTempDataProvider();
        }
        
        internal void PossiblyLoadTempData()
        {
            //檢查當前請求的Action是否爲子Action。
            //即：在View中是否應用了@Html.Action()，若是在View中嵌套了一個@Html.Action(action2)，則這個action2也是須要再被執行一次的！即便Action的View中嵌套了一個Action，整個過程仍是被
            //      認爲是一次請求的，此處判斷條件的目的是防止被嵌套的Action再去執行。
            if (!ControllerContext.IsChildAction)
            {
                //TempData是基類ControllerBase中的屬性
                //此處是TempData屬性被第一次使用，獲得TempDataDictionary對象後，再執行此對象的Load方法，這個方法就是去實現獲取上一次處理請求時沒使用的TempData功能的！
                //參數TempDataProvider是關鍵，它是Controller類的一個屬性（就是一個SessionStateTempDataProvider對象），正如參數名的翻譯這個參數就是負責去請求上下文中檢查並獲取值的！
                TempData.Load(ControllerContext, TempDataProvider);
            }
        }
        
    }
Controller 
    public abstract class ControllerBase : IController
    {

        private TempDataDictionary _tempDataDictionary;
        //此時的ControllerContext是已經封裝 請求上下文、路由、當情請求的控制器對象。（在執行ExecuteCore方法以前的Execute方法中設置的！）
        public ControllerContext ControllerContext { get; set; }

        //第一次使用TempData屬性時（即：PossiblyLoadTempData方法是第一次使用），會建立一個TempDataDictionary對象並賦值給變量_tempDataDictionary，屬性的返回值就是該_tempDataDictionary變量。
        //之後再使用TempData屬性時，返回都是第一次建立的那個TempDataDictionary對象，因此咱們在Action方法中使用TempData[""]時，就是調用TempDataDictionary對象的索引器，向
        //保存TempData集合添加一個鍵值對。
        public TempDataDictionary TempData
        {
            get
            {
                if (ControllerContext != null && ControllerContext.IsChildAction)
                {
                    return ControllerContext.ParentActionViewContext.TempData;
                }
                if (_tempDataDictionary == null)
                {
                    //實例化TempDataDictionary，在構造函數中會建立一個不區分key大小寫的字典表，並賦值給一個私有字段。
                    _tempDataDictionary = new TempDataDictionary();
                }
                return _tempDataDictionary;
            }
            set { _tempDataDictionary = value; }
        }
    }
ControllerBase 
    public class TempDataDictionary : IDictionary<string, object>
    {
        internal const string TempDataSerializationKey = "__tempData";

        private Dictionary<string, object> _data;
        private HashSet<string> _initialKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        private HashSet<string> _retainedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        public TempDataDictionary()
        {
            //初始化key不區分大小寫的字典類
            _data = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }

        public ICollection<string> Keys
        {
            get { return _data.Keys; }
        }
        //TempData["MyKey"]=MyValue，就是調用此索引器
        //使用TempData時候，也是用這個索引，以後介紹！
        public object this[string key]
        {
            get
            {
                object value;
                if (TryGetValue(key, out value))
                {
                    _initialKeys.Remove(key);
                    return value;
                }
                return null;
            }
            set
            {
                _data[key] = value;
                _initialKeys.Add(key);
            }
        }

        public void Load(ControllerContext controllerContext, ITempDataProvider tempDataProvider)
        {
            //從Session中獲取上一次請求中沒有被使用的TempData
            IDictionary<string, object> providerDictionary = tempDataProvider.LoadTempData(controllerContext);
            //若是從Session中獲取的值不爲null，則將Session獲取的值賦值給_data（將上次沒使用的TempData再次添加到集合中）。
            //這裏的判斷providerDictionary != null其實是判斷取值是否出錯。
            //由於tempDataProvider.LoadTempData(controllerContext)方法從Session中獲取值時，若是有值，則返回一個其中有鍵值對IDictionary<string, object>對象，不然返回一個沒有值的IDictionary<string, object>對象
            _data = (providerDictionary != null)
                ? new Dictionary<string, object>(providerDictionary, StringComparer.OrdinalIgnoreCase)
                : new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            //並將TempData的全部key保存到_initialKeys中！
            _initialKeys = new HashSet<string>(_data.Keys, StringComparer.OrdinalIgnoreCase);
            //清空_retainedKeys中的值，因此默認狀況下，_retainedKeys的值爲空
            _retainedKeys.Clear();
        }
    }
TempDataDictionary 
    public class SessionStateTempDataProvider : ITempDataProvider
    {
        internal const string TempDataSessionStateKey = "__ControllerTempData";

        public virtual IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
        {
            HttpSessionStateBase session = controllerContext.HttpContext.Session;
            //這裏不是判斷上下文中是否含有Session的key，應該是請求是否出現異常！
            if (session != null)
            {    
                //根據key=__ControllerTempData去服務器的Session中獲取值
                Dictionary<string, object> tempDataDictionary = session[TempDataSessionStateKey] as Dictionary<string, object>;
                //若是Session中保存key爲__ControllerTempData的值不爲空，表示：上次處理請求時存在麼有被使用的TempData，那麼就返回這個字典對象（以後再添加到保存TempData的集合中，以供本次請求使用）。
                //並將服務器的key=__ControllerTempData的Session移除！
                if (tempDataDictionary != null)
                {
                    session.Remove(TempDataSessionStateKey);
                    return tempDataDictionary;
                }
            }
            return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }   
    }
SessionStateTempDataProvider 
    public class DependencyResolver
    {
        //靜態字段，因此在程序執行前就已經執行了該類的構造函數。
        private static DependencyResolver _instance = new DependencyResolver();
        private IDependencyResolver _current;
        private CacheDependencyResolver _currentCache;
        
        internal static IDependencyResolver CurrentCache
        {
            get { return _instance.InnerCurrentCache; }
        }
        internal IDependencyResolver InnerCurrentCache
        {
            get { return _currentCache; }
        }

        //構造函數
        public DependencyResolver()
        {
            InnerSetResolver(new DefaultDependencyResolver());
        }

        //構造函數調用此方法
        public void InnerSetResolver(IDependencyResolver resolver)
        {
            //參數resolver=new DefaultDependencyResolver()
            //DefaultDependencyResolver類的功能爲：經過反射根據類型建立對象！
            _current = resolver;
            _currentCache = new CacheDependencyResolver(_current);
        }

        //由於DependencyResolver只在靜態字段中進行了實例化，全部這個CacheDependencyResolver也只實例化一次。因此，ConcurrentDictionary字典也只實例化一次，故，在一次請求中這個集合是一直存在的！
        private sealed class CacheDependencyResolver : IDependencyResolver
        {
            private readonly ConcurrentDictionary<Type, object> _cache = new ConcurrentDictionary<Type, object>();
            private readonly ConcurrentDictionary<Type, IEnumerable<object>> _cacheMultiple = new ConcurrentDictionary<Type, IEnumerable<object>>();
            private readonly Func<Type, object> _getServiceDelegate;
            private readonly Func<Type, IEnumerable<object>> _getServicesDelegate;

            private readonly IDependencyResolver _resolver;

            public CacheDependencyResolver(IDependencyResolver resolver)
            {
                _resolver = resolver;
                //這個委託就是DefaultDependencyResolver實例的GetService方法，利用類型建立實例。
                //目的就是當集合中沒有類型對應的值（實例）時，就經過DefaultDependencyResolver的GetService方法去再去反射建立實例。
                _getServiceDelegate = _resolver.GetService;
                _getServicesDelegate = _resolver.GetServices;
            }

            public object GetService(Type serviceType)
            {
                //先根據serviceType去集合的key中找，若是對應的key有值，則直接將值返回。若是沒有，則將serviceType做爲參數執行_getServiceDelegate委託，而後將執行委託後的返回值（利用類型建立對象）返回，並將此serviceType和執行委託後的返回值添加到集合中！
                return _cache.GetOrAdd(serviceType, _getServiceDelegate);
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                // Use a saved delegate to prevent per-call delegate allocation
                return _cacheMultiple.GetOrAdd(serviceType, _getServicesDelegate);
            }
        }

        private class DefaultDependencyResolver : IDependencyResolver
        {
            public object GetService(Type serviceType)
            {
                if (serviceType.IsInterface || serviceType.IsAbstract)
                {
                    return null;
                }

                try
                {
                    return Activator.CreateInstance(serviceType);
                }
                catch
                {
                    return null;
                }
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                return Enumerable.Empty<object>();
            }
        

            private Func<Type, object> _getService;
            private Func<Type, IEnumerable<object>> _getServices;

            public DelegateBasedDependencyResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
            {
                _getService = getService;
                _getServices = getServices;
            }

            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method might throw exceptions whose type we cannot strongly link against; namely, ActivationException from common service locator")]
            public object GetService(Type type)
            {
                try
                {
                    return _getService.Invoke(type);
                }
                catch
                {
                    return null;
                }
            }

            public IEnumerable<object> GetServices(Type type)
            {
                return _getServices(type);
            }
        }
    }
DependencyResolver

 　　上述代碼，TempDataDictionary類就是程序中使用的TempData的類型，SessionStateTempDataProvider類用於服務器Session中獲取上一次沒有被使用的TempData的集合，DependencyResolver類在上一節的Controller激活中已經介紹過了，它主要是用於根據類型經過反射建立實例（還具備緩存的功能）。
補充：對於咱們定義的TempData["kk"]=value，若是在使用時也是執行的TempDataDictionary類的索引器，在索引器的Set中可看到，若是使用TempData以後，是在【_initialKeys】中將key移除，而不是直接在保存全部TempData的集合【_data】中移除。
猜測：MVC3和MVC4中對TempData的使用不同

 3-二、ActionInvoker.InvokeAction(ControllerContext, actionName)

 　　此代碼實現了：Action的執行、過濾器的執行、View的呈現。
　　因爲這部分的內容太多，爲避免影響知識點混亂，將再開一篇博文來詳細介紹！《白話學習MVC(八)Action的執行2》

3-三、PossiblySaveTempData()

　　從保存着全部TempData的集合中移除已經被使用的TempData，最後再將全部沒有被使用TempData集合保存在key=__ControllerTempData的Session中！以便下次請求中使用。

    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        protected override void ExecuteCore()
        {
            //獲取上次處理過程當中沒有被使用的TempData
            PossiblyLoadTempData();
            try
            {
                //從路由數據中獲取請求的Action的名字
                string actionName = RouteData.GetRequiredString("action");
                //ActionInvoker爲一個AsyncControllerActionInvoker對象
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                //將TempData保存到Session中。等待以後將Session的key【__ControllerTempData】發送到響應流中！
                PossiblySaveTempData();
            }
        }
        private ITempDataProvider _tempDataProvider;
        
        internal IDependencyResolver Resolver
        {
            get { return _resolver ?? DependencyResolver.CurrentCache; }
            set { _resolver = value; }
        }
        
        public ITempDataProvider TempDataProvider
        {
            get
            {
                if (_tempDataProvider == null)
                {
                    _tempDataProvider = CreateTempDataProvider();
                }
                return _tempDataProvider;
            }
            set { _tempDataProvider = value; }
        }
        
        protected virtual ITempDataProvider CreateTempDataProvider()
        {
            //Resolver是Controller的一個屬性，返回值爲：DependencyResolver.CurrentCache
            //Resolver.GetService<ITempDataProvider>() 能夠不用看，由於返回的是null。這個方法其實先根據key=ITempDataProvider從全局的緩存表中查找值，若是有值，則返回。若是沒有，則利用DefaultDependencyResolver對象經過反射
            //根據類型ITempDataProvider建立對象。可是因爲這裏的ITempDataProvider是接口，而DefaultDependencyResolver對象反射建立對象時，若是是接口或抽象類均返回null。詳細請看DependencyResolver類！
            //因此這段代碼，返回值就是 new SessionStateTempDataProvider();
            return Resolver.GetService<ITempDataProvider>() ?? new SessionStateTempDataProvider();
        }
        
        internal void PossiblySaveTempData()
        {
            if (!ControllerContext.IsChildAction)
            {
                //最後一次使用TempData，TempData屬性定義在基類ControllerBase中
                TempData.Save(ControllerContext, TempDataProvider);
            }
        }
    
    }
Controller 
    public abstract class ControllerBase : IController
    {

        private TempDataDictionary _tempDataDictionary;
        //此時的ControllerContext是已經封裝 請求上下文、路由、當情請求的控制器對象。（在執行ExecuteCore方法以前的Execute方法中設置的！）
        public ControllerContext ControllerContext { get; set; }

        //第一次使用TempData屬性時（即：PossiblyLoadTempData方法是第一次使用），會建立一個TempDataDictionary對象並賦值給變量_tempDataDictionary，屬性的返回值就是該_tempDataDictionary變量。
        //之後再使用TempData屬性時，返回都是第一次建立的那個TempDataDictionary對象，因此咱們在Action方法中使用TempData[""]時，就是調用TempDataDictionary對象的索引器，向
        //保存TempData集合添加一個鍵值對。
        //此時不是第一次使用TempData，應該是最後一次了
        public TempDataDictionary TempData
        {
            get
            {
                if (ControllerContext != null && ControllerContext.IsChildAction)
                {
                    return ControllerContext.ParentActionViewContext.TempData;
                }
                if (_tempDataDictionary == null)
                {
                    //實例化TempDataDictionary，在構造函數中會建立一個不區分key大小寫的字典表，並賦值給一個私有字段。
                    _tempDataDictionary = new TempDataDictionary();
                }
                return _tempDataDictionary;
            }
            set { _tempDataDictionary = value; }
        }
    }
ControllerBase 
    public class TempDataDictionary : IDictionary<string, object>
    {
        private Dictionary<string, object> _data;
        private HashSet<string> _initialKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        private HashSet<string> _retainedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        
        //沒有執行Action以前，對TempData的操做
        public void Load(ControllerContext controllerContext, ITempDataProvider tempDataProvider)
        {
            //從Session中獲取上一次請求中沒有被使用的TempData
            IDictionary<string, object> providerDictionary = tempDataProvider.LoadTempData(controllerContext);
            //若是從Session中獲取的值不爲null，則將Session獲取的值賦值給_data（將上次沒使用的TempData再次添加到集合中）。
            //這裏的判斷providerDictionary != null其實是判斷取值是否出錯。
            //由於tempDataProvider.LoadTempData(controllerContext)方法從Session中獲取值時，若是有值，則返回一個其中有鍵值對IDictionary<string, object>對象，不然返回一個沒有值的IDictionary<string, object>對象
            _data = (providerDictionary != null)
                ? new Dictionary<string, object>(providerDictionary, StringComparer.OrdinalIgnoreCase)
                : new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            //並將TempData的全部key保存到_initialKeys中！
            _initialKeys = new HashSet<string>(_data.Keys, StringComparer.OrdinalIgnoreCase);
            //清空_retainedKeys中的值
            _retainedKeys.Clear();
        }
        
        public void Save(ControllerContext controllerContext, ITempDataProvider tempDataProvider)
        {
            //RemoveFromDictionary方法是MVC中爲IDictionary<TKey, TValue>的建立的一個擴展方法。
            //RemoveFromDictionary方法做用：檢查TempData是否被使用過，若是已被使用，則將其在保存全部TempData集合(_data)中移除。
            //須知：當使用TempData時，只是在_initialKeys中將key移除，並無在保存全部TempData集合(_data)中移除（見TempDataDictionary類的索引器）
            _data.RemoveFromDictionary((KeyValuePair<string, object> entry, TempDataDictionary tempData) =>
                {
                    string key = entry.Key;
                    //只有當前TempDataDictionary對象的_initialKeys和_retainedKeys中都不含有_data中的key時，委託才返回true。
                    //_initialKeys和_retainedKeys初始化都是在 Load 方法中，_initialKeys中的值爲全部TempData的key，而_retainedKeys是爲空的集合
                    //目前所知，由於retainedKeys是爲空的集合，因此tempData._retainedKeys.Contains(key)爲：false
                    //而當使用TempData時，只是在_initialKeys中將key移除。因此，若是是被使用過的TempData，則tempData._initialKeys.Contains(key)爲：false，不然都爲true
                    //最終得出：若是當前循環的TempData被使用了，則返回ture，不然返回false
                    return !tempData._initialKeys.Contains(key)&& !tempData._retainedKeys.Contains(key);
                }, this);
            //將全部沒有被使用的TempData的集合添加到服務器Session中，以便下次請求再使用
            tempDataProvider.SaveTempData(controllerContext, _data);
        }
        
    }
TempDataDictionary 
    internal static class DictionaryExtensions
    {
        //此時的TState類型爲：TempDataDictionary
        public static void RemoveFromDictionary<TKey, TValue, TState>(this IDictionary<TKey, TValue> dictionary, Func<KeyValuePair<TKey, TValue>, TState, bool> removeCondition, TState state)
        {
            Contract.Assert(dictionary != null);
            Contract.Assert(removeCondition != null);

            int removeCount = 0;
            TKey[] keys = new TKey[dictionary.Count];
            //循環全部的TempData，讓每一個循環項執行委託removeCondition
            foreach (var entry in dictionary)
            {
                //對於委託執行removeCondition若是當前循環的TempData被使用了，則返回ture，不然返回false
                if (removeCondition(entry, state))
                {
                    //將已經被使用的TempData的key添加到keys數組中
                    //removeCount++表示已經被使用的TempData個數。
                    keys[removeCount] = entry.Key;
                    removeCount++;
                }
            }
            //循環被刪除的TempData個數，將該鍵值對在保存全部TempData的集合中移除。
            for (int i = 0; i < removeCount; i++)
            {
                dictionary.Remove(keys[i]);
            }
        }
    }
DictionaryExtensions 
    public class SessionStateTempDataProvider : ITempDataProvider
    {
        internal const string TempDataSessionStateKey = "__ControllerTempData";
        
        public virtual void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            HttpSessionStateBase session = controllerContext.HttpContext.Session;
            bool isDirty = (values != null && values.Count > 0);
            //這裏的判斷：不是沒有Sesson，由於即便是第一次請求到來時（無任何Session），這個對象也不爲空。
            //而是根據上下文因爲建立HttpSessionStateBase對象時出問題，該對象爲空。
            if (session == null)
            {
                if (isDirty)
                {
                    throw new InvalidOperationException(MvcResources.SessionStateTempDataProvider_SessionStateDisabled);
                }
            }
            //HttpSessonStateBase對象建立沒問題
            else
            {    
                //若是保存TempData的字典類實例中有值（也就是定義的TempData沒有在view中被全使用），將值設置給key爲__ControllerTempData的Session。
                if (isDirty)
                {
                    session[TempDataSessionStateKey] = values;
                }
                //TempData在view中所有已被使用
                else
                {
                    //而且Session中該能夠__ControllerTempData還有對應的值
                    //若是用戶在Action中本身定義一個key爲__ControllerTempData的Session，這裏移除Session中的這個值，防止了將這個key發送到相應流，以僞形成未被利用的TempData
                    if (session[TempDataSessionStateKey] != null)
                    {
                        session.Remove(TempDataSessionStateKey);
                    }
                }
            }
        }
    
   }
SessionStateTempDataProvider

 　　上述代碼，PossiblySaveTempData方法執行 TempData.Save(ControllerContext, TempDataProvider)來完成全部的功能，TempData獲得的以前建立的TempDataDictionary對象（該對象的_data字段保存這定義的全部TempData鍵值對），參數TempDataProvider是建立的SessionStateTempDataProvider對象（該對象的SaveTempData方法的做用就是將沒有被使用的TempData保存到Session中）。因此，TempDataDictionary對象的Save方法首先去遍歷全部的TempData，檢查TempData是否被使用過了，若是已被使用，則將該TempData在保存全部TempData的集合中移除，最後執行SessionStateTempDataProvider對象的SaveTempData方法將通過處理後的集合添加到Session中，以便這些TempData在寫一次請求中使用！
　　如3-1中補充到，對於咱們定義的TempData["kk"]=value，若是在使用時是執行的TempDataDictionary類的索引器，在索引器的Set中可看到，若是使用TempData以後，是在【_initialKeys】中將key移除，而不是直接在保存全部TempData的集合【_data】中移除。此處作的就是在根據【_initialKeys】將被使用的TempData在【_data】中移除。

 

 以上就是所有內容，若有不合適之處請指教!

遺留問題：

　　一、如何利用各擴展點暫沒有分析。

疑問：

　　一、既然利用DependencyResolver經過反射建立對象時，接口和抽象類都不能夠，MVC中爲何還在使用GetService方法使用接口來建立對象呀？明知是Null

 更正：

　　一、以上的Controller類的繼承關係是MVC5中的，在MVC4中應該是以下，MVC4中沒有引進IAuthenticationFilter過濾器。

public abstract class Controller : ControllerBase, IActionFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        ...
    }
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程