目录
- 一、介绍
- 二、mvc生命周期详述
- view的初始化和渲染呈现
- 三、结束
一、介绍
我们做开发的，尤其是做微软技术栈的，有一个方向是跳不过去的，那就是mvc开发。我相信大家，做asp.net mvc 开发有的有很长时间，当然，也有刚进入这个行业的。无论如何，如果有人问你，你知道asp.net mvc的生命周期吗？你知道它的来世今生吗？你知道它和 asp.net webform 有什么区别吗?估计，这些问题，有很多人会答不上来，或者说不清楚。今天，我就把我的理解写出来，也是对我自己学习的一次回顾和总结吧。当然，由于本人能力有限，在写的过程中也可能会有一些错误，希望大家多多包涵，当然，更希望大家能不灵赐教，我们共同进步。
在开始之前，我们先来说说，asp.net web form 和 asp.net mvc 有什么区别，这里说的区别，当然是本质区别，不是适用语法那个层次的。其实，说起来，asp.net web form 和 asp.net mvc 它们两个没有本质区别，使用的都是asp.net web form 的管道处理模型，asp.net mvc 也是通过扩展 ihttpmodule 和 ihttphandler 来实现的，都是基于 asp.net 的 httpapplication 的管道处理模型扩展的，在这个层面来说，它们是一样的。当然，大家不要抬杠，我说的本质区别都是在这个方面，不同意的勿喷。
有人会问，asp.net mvc 和 asp.net webapi 它们会有什么不同吗？好像 webapi 能做的，webmvc都可以完成，第一眼看上去，好像是这样，但是它们有着本质的不同。webapi 的处理管道是重新写过的，不是基于 httpapplication 管道扩展的。asp.net web api 类似专人做专事，它的管道处理模型更高效，并且有了 restfull 的概念。当然，大家如何向了解更细的内容，就需要看源码了。或再说回来，到了 net core 时代，二者又融合管道了。
二、mvc生命周期详述
1、我们既然要说 asp.net mvc的生命周期，为了给大家一个整体印象，俗话说，文不如图，我就贴一张图，按着箭头走，相信大家也会不能理解。
2、上图很简单，大家按着箭头走，也能理解的差不多。以下是按着我的理解，划分了4个模块。
（1）、路由模块
routebase 是对路由规则的抽象，也就是说，一个 routebase 对象，也就代表了一个条 路由规则。在 asp.net mvc 中，有一个唯一的子类实现就是 route ，它同样也是路由规则的代表。我们有了路由规则，一定会把这个规则存放在一个地方，这个地方保存了很多路由规则，这个地方就是 routecollection，中文叫“路由集合”，因为这个集合里面包含的就是 routebase 对象。
routecollection 就是路由集合，用于保存路由规则对象，它的定义形式：
[typeforwardedfrom("system.web.routing, version=3.5.0.0, culture=neutral, publickeytoken=31bf3856ad364e35")]
public class routecollection : collection<routebase>
{
private class readlockdisposable : idisposable
{
private readerwriterlockslim _rwlock;
public readlockdisposable(readerwriterlockslim rwlock)
{
this._rwlock = rwlock;
}
void idisposable.dispose()
{
this._rwlock.exitreadlock();
}
}
......
routetable 就是路由表，其实它和 routecollection 是一样的。
public class routetable
{
private static routecollection _instance = new routecollection();
public static routecollection routes
{
get
{
return routetable._instance;
}
}
}
在asp.net mvc处理管线中的第一站就是路由模块。当请求到达路由模块后，asp.net mvc 框架就会根据 routetable 中配置的路由模板来匹配当前请求以获得对应的 controller 和 action 信息。具体的匹配过程就是有urlroutingmodule(system.web.routing.urlroutingmodule)来实现的。如果遇到一个匹配的规则，就会立刻跳出下面的配置。也就是说，配置过程是有顺序的，如果有一个匹配，后面就算有匹配的也不会执行的。
namespace system.web.routing
{
[typeforwardedfrom("system.web.routing, version=3.5.0.0, culture=neutral, publickeytoken=31bf3856ad364e35")]
public class urlroutingmodule : ihttpmodule
{
private static readonly object _contextkey = new object();
private static readonly object _requestdatakey = new object();
private routecollection _routecollection;
public routecollection routecollection
{
get
{
if (this._routecollection == null)
{
this._routecollection = routetable.routes;
}
return this._routecollection;
}
set
{
this._routecollection = value;
}
}
protected virtual void dispose()
{
}
protected virtual void init(httpapplication application)
{
if (application.context.items[urlroutingmodule._contextkey] != null)
{
return;
}
application.context.items[urlroutingmodule._contextkey] = urlroutingmodule._contextkey;
application.postresolverequestcache += new eventhandler(this.onapplicationpostresolverequestcache);
}
private void onapplicationpostresolverequestcache(object sender, eventargs e)
{
httpapplication httpapplication = (httpapplication)sender;
httpcontextbase context = new httpcontextwrapper(httpapplication.context);
this.postresolverequestcache(context);
}
[obsolete("this method is obsolete. override the init method to use the postmaprequesthandler event.")]
public virtual void postmaprequesthandler(httpcontextbase context)
{
}
public virtual void postresolverequestcache(httpcontextbase context)
{
routedata routedata = this.routecollection.getroutedata(context); 第一步匹配路由规则
if (routedata == null)
{
return;
}
iroutehandler routehandler = routedata.routehandler; 第二步：如有匹配，就找到routehandler对象，该类型的实例是：mvcroutehandler。
if (routehandler == null)
{
throw new invalidoperationexception(string.format(cultureinfo.currentculture, sr.getstring("urlroutingmodule_noroutehandler"), new object[0]));
}
if (routehandler is stoproutinghandler)
{
return;
}
requestcontext requestcontext = new requestcontext(context, routedata);
context.request.requestcontext = requestcontext;
ihttphandler httphandler = routehandler.gethttphandler(requestcontext);第三步，根据 routehandler 对象，找到最终处理请求的 ihttphandler 的对象，该类型是 mvchandler
if (httphandler == null)
{
throw new invalidoperationexception(string.format(cultureinfo.currentuiculture, sr.getstring("urlroutingmodule_nohttphandler"), new object[]
{
routehandler.gettype()
}));
}
if (!(httphandler is urlauthfailurehandler))
{
context.remaphandler(httphandler);第四步，有找到的 ihttphandler 处理请求。
return;
}
if (formsauthenticationmodule.formsauthrequired)
{
urlauthorizationmodule.reporturlauthorizationfailure(httpcontext.current, this);
return;
}
throw new httpexception(401, sr.getstring("assess_denied_description3"));
}
void ihttpmodule.dispose()
{
this.dispose();
}
void ihttpmodule.init(httpapplication application)
{
this.init(application);
}
}
}
（2）、controller 创建模块
经过了路由模块，生成了 routedata 路由数据，它包含了根据路由规则匹配的 controller 和 action。有了路由数据，需要有处理器来处理请求，这个任务就交给了 routedata 的 routehandler 属性，它的类型是 iroutehandler，它的值就是mvcroutehandler，mvcroutehandler 调用 gethttphandler 获取处理请求的 ihttphandler 对象，在 mvc 框架中就是 mvchandler，详细代码如下：
namespace system.web.mvc
{
/// <summary>selects the controller that will handle an http request.</summary>
public class mvchandler : ihttpasynchandler, ihttphandler, irequiressessionstate
{
private struct processrequeststate
{
internal iasynccontroller asynccontroller;
internal icontrollerfactory factory;
internal requestcontext requestcontext;
internal void releasecontroller()
{
this.factory.releasecontroller(this.asynccontroller);
}
}
[compilergenerated]
[serializable]
private sealed class <>c
{
public static readonly mvchandler.<>c <>9 = new mvchandler.<>c();
public static begininvokedelegate<mvchandler.processrequeststate> <>9__20_0;
public static endinvokevoiddelegate<mvchandler.processrequeststate> <>9__20_1;
public static func<keyvaluepair<string, object>, bool> <>9__26_0;
internal iasyncresult <beginprocessrequest>b__20_0(asynccallback asynccallback, object asyncstate, mvchandler.processrequeststate innerstate)
{
iasyncresult result;
try
{
result = innerstate.asynccontroller.beginexecute(innerstate.requestcontext, asynccallback, asyncstate);
}
catch
{
innerstate.releasecontroller();
throw;
}
return result;
}
internal void <beginprocessrequest>b__20_1(iasyncresult asyncresult, mvchandler.processrequeststate innerstate)
{
try
{
innerstate.asynccontroller.endexecute(asyncresult);
}
finally
{
innerstate.releasecontroller();
}
}
internal bool <removeoptionalroutingparameters>b__26_0(keyvaluepair<string, object> entry)
{
return entry.value == urlparameter.optional;
}
}
private static readonly object _processrequesttag = new object();
internal static readonly string mvcversion = mvchandler.getmvcversionstring();
/// <summary>contains the header name of the asp.net mvc version.</summary>
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;
}
}
/// <summary>gets or sets a value that indicates whether the mvc response header is disabled.</summary>
/// <returns>true if the mvc response header is disabled; otherwise, false.</returns>
public static bool disablemvcresponseheader
{
get;
set;
}
/// <summary>gets a value that indicates whether another request can use the <see cref="t:system.web.ihttphandler" /> instance.</summary>
/// <returns>true if the <see cref="t:system.web.ihttphandler" /> instance is reusable; otherwise, false.</returns>
protected virtual bool isreusable
{
get
{
return false;
}
}
/// <summary>gets the request context.</summary>
/// <returns>the request context.</returns>
public requestcontext requestcontext
{
get;
private set;
}
/// <summary>gets a value that indicates whether another request can use the <see cref="t:system.web.ihttphandler" /> instance.</summary>
/// <returns>true if the <see cref="t:system.web.ihttphandler" /> instance is reusable; otherwise, false.</returns>
bool ihttphandler.isreusable
{
get
{
return this.isreusable;
}
}
/// <summary>initializes a new instance of the <see cref="t:system.web.mvc.mvchandler" /> class.</summary>
/// <param name="requestcontext">the request context.</param>
/// <exception cref="t:system.argumentnullexception">the <paramref name="requestcontext" /> parameter is null.</exception>
public mvchandler(requestcontext requestcontext)
{
if (requestcontext == null)
{
throw new argumentnullexception("requestcontext");
}
this.requestcontext = requestcontext;
}
/// <summary>adds the version header by using the specified http context.</summary>
/// <param name="httpcontext">the http context.</param>
protected internal virtual void addversionheader(httpcontextbase httpcontext)
{
if (!mvchandler.disablemvcresponseheader)
{
httpcontext.response.appendheader(mvchandler.mvcversionheadername, mvchandler.mvcversion);
}
}
/// <summary>called by asp.net to begin asynchronous request processing.</summary>
/// <returns>the status of the asynchronous call.</returns>
/// <param name="httpcontext">the http context.</param>
/// <param name="callback">the asynchronous callback method.</param>
/// <param name="state">the state of the asynchronous object.</param>
protected virtual iasyncresult beginprocessrequest(httpcontext httpcontext, asynccallback callback, object state)
{
httpcontextbase httpcontext2 = new httpcontextwrapper(httpcontext);
return this.beginprocessrequest(httpcontext2, callback, state);
}
/// <summary>called by asp.net to begin asynchronous request processing using the base http context.</summary>
/// <returns>the status of the asynchronous call.</returns>
/// <param name="httpcontext">the http context.</param>
/// <param name="callback">the asynchronous callback method.</param>
/// <param name="state">the state of the asynchronous object.</param>
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<mvchandler.processrequeststate> arg_51_0;
if ((arg_51_0 = mvchandler.<>c.<>9__20_0) == null)
{
arg_51_0 = (mvchandler.<>c.<>9__20_0 = new begininvokedelegate<mvchandler.processrequeststate>(mvchandler.<>c.<>9.<beginprocessrequest>b__20_0));
}
begininvokedelegate<mvchandler.processrequeststate> begindelegate = arg_51_0;
endinvokevoiddelegate<mvchandler.processrequeststate> arg_71_0;
if ((arg_71_0 = mvchandler.<>c.<>9__20_1) == null)
{
arg_71_0 = (mvchandler.<>c.<>9__20_1 = new endinvokevoiddelegate<mvchandler.processrequeststate>(mvchandler.<>c.<>9.<beginprocessrequest>b__20_1));
}
endinvokevoiddelegate<mvchandler.processrequeststate> enddelegate = arg_71_0;
mvchandler.processrequeststate invokestate = new mvchandler.processrequeststate
{
asynccontroller = asynccontroller,
factory = factory,
requestcontext = this.requestcontext
};
synchronizationcontext synchronizationcontext = synchronizationcontextutil.getsynchronizationcontext();
return asyncresultwrapper.begin<mvchandler.processrequeststate>(callback, state, begindelegate, enddelegate, invokestate, mvchandler._processrequesttag, -1, synchronizationcontext);
}
action action = delegate
{
try
{
controller.execute(this.requestcontext);
}
finally
{
factory.releasecontroller(controller);
}
};
return asyncresultwrapper.beginsynchronous(callback, state, action, mvchandler._processrequesttag);
}
/// <summary>called by asp.net when asynchronous request processing has ended.</summary>
/// <param name="asyncresult">the asynchronous result.</param>
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);
}
/// <summary>processes the request by using the specified http request context.</summary>
/// <param name="httpcontext">the http context.</param>
protected virtual void processrequest(httpcontext httpcontext)
{
httpcontextbase httpcontext2 = new httpcontextwrapper(httpcontext);
this.processrequest(httpcontext2);
}
/// <summary>processes the request by using the specified base http request context.</summary>
/// <param name="httpcontext">the http context.</param>
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)
{
bool? flag = validationutility.isvalidationenabled(current);
bool flag2 = true;
if (flag.getvalueordefault() == flag2 & flag.hasvalue)
{
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()
{
idictionary<string, object> arg_2f_0 = this.requestcontext.routedata.values;
func<keyvaluepair<string, object>, bool> arg_2f_1;
if ((arg_2f_1 = mvchandler.<>c.<>9__26_0) == null)
{
arg_2f_1 = (mvchandler.<>c.<>9__26_0 = new func<keyvaluepair<string, object>, bool>(mvchandler.<>c.<>9.<removeoptionalroutingparameters>b__26_0));
}
arg_2f_0.removefromdictionary(arg_2f_1);
}
/// <summary>enables processing of http web requests by a custom http handler that implements the <see cref="t:system.web.ihttphandler" /> interface.</summary>
/// <param name="httpcontext">an <see cref="t:system.web.httpcontext" /> object that provides references to the intrinsic server objects (for example, request, response, session, and server) that are used to service http requests.</param>
void ihttphandler.processrequest(httpcontext httpcontext)
{
this.processrequest(httpcontext);
}
/// <summary>called by asp.net to begin asynchronous request processing using the base http context.</summary>
/// <returns>the status of the asynchronous call.</returns>
/// <param name="context">the http context.</param>
/// <param name="cb">the asynchronous callback method.</param>
/// <param name="extradata">the data.</param>
iasyncresult ihttpasynchandler.beginprocessrequest(httpcontext context, asynccallback cb, object extradata)
{
return this.beginprocessrequest(context, cb, extradata);
}
/// <summary>called by asp.net when asynchronous request processing has ended.</summary>
/// <param name="result">the asynchronous result.</param>
void ihttpasynchandler.endprocessrequest(iasyncresult result)
{
this.endprocessrequest(result);
}
}
}
httpruntime 调用 ihttphandler 类型的调用 processrequest() 方法，用于处理请求。
protected internal virtual void processrequest(httpcontextbase httpcontext)
{
icontroller controller;
icontrollerfactory controllerfactory;
this.processrequestinit(httpcontext, out controller, out controllerfactory);创建 icontrollerfactory，并创建 icontroller 对象。
try
{
controller.execute(this.requestcontext);执行controller，背后就是调用相应的 action 方法。
}
finally
{
controllerfactory.releasecontroller(controller);
}
}
核心处理请求的方法是processrequestinit()，用于创建 icontroller 和 icontrollerfactory 实例。icontrollerfactory 的实际类型是：defaultcontrollerfactory，该类型用于创建 icontroller 类型的实例。
private void processrequestinit(httpcontextbase httpcontext, out icontroller controller, out icontrollerfactory factory)
{
httpcontext current = httpcontext.current;
if (current != null)
{
bool? flag = validationutility.isvalidationenabled(current);
bool flag2 = true;
if (flag.getvalueordefault() == flag2 & flag.hasvalue)
{
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
}));
}
}
以上加红的代码就是创建 icontroller 的实例的逻辑。icontroller 实例创建完成后，判断是否实现了 iasynccontroller 接口，如果是，就异步执行 controller 方法的调用，否则就同步执行。
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<mvchandler.processrequeststate> arg_51_0;
if ((arg_51_0 = mvchandler.<>c.<>9__20_0) == null)
{
arg_51_0 = (mvchandler.<>c.<>9__20_0 = new begininvokedelegate<mvchandler.processrequeststate>(mvchandler.<>c.<>9.<beginprocessrequest>b__20_0));
}
begininvokedelegate<mvchandler.processrequeststate> begindelegate = arg_51_0;
endinvokevoiddelegate<mvchandler.processrequeststate> arg_71_0;
if ((arg_71_0 = mvchandler.<>c.<>9__20_1) == null)
{
arg_71_0 = (mvchandler.<>c.<>9__20_1 = new endinvokevoiddelegate<mvchandler.processrequeststate>(mvchandler.<>c.<>9.<beginprocessrequest>b__20_1));
}
endinvokevoiddelegate<mvchandler.processrequeststate> enddelegate = arg_71_0;
mvchandler.processrequeststate invokestate = new mvchandler.processrequeststate
{
asynccontroller = asynccontroller,
factory = factory,
requestcontext = this.requestcontext
};
synchronizationcontext synchronizationcontext = synchronizationcontextutil.getsynchronizationcontext();
return asyncresultwrapper.begin<mvchandler.processrequeststate>(callback, state, begindelegate, enddelegate, invokestate, mvchandler._processrequesttag, -1, synchronizationcontext);
}
action action = delegate//同步执行。
{
try
{
controller.execute(this.requestcontext);
}
finally
{
factory.releasecontroller(controller);
}
};
return asyncresultwrapper.beginsynchronous(callback, state, action, mvchandler._processrequesttag);
}
（3）、action 执行模块，通过 controlleractioninvoker 调用 invokeaction() 执行其方法。action 方法的执行也有2个版本，一个是异步版本，一个是同步版本。由于 actioninvoker 实现了 iasyncactioninvoker 接口，所以也是以已方式执行。该类型是 asynccontrolleractioninvoker。
a、当controller对象被创建之后，紧接着就会执行controler 对象的 execute()，其实背后就是调用 invokeaction() 方法：
public virtual bool invokeaction(controllercontext controllercontext, string actionname)
{
if (controllercontext == null)
{
throw new argumentnullexception("controllercontext");
}
if (string.isnullorempty(actionname) && !controllercontext.routedata.hasdirectroutematch())
{
throw new argumentexception(mvcresources.common_nullorempty, "actionname");
}
controllerdescriptor controllerdescriptor = this.getcontrollerdescriptor(controllercontext);
actiondescriptor actiondescriptor = this.findaction(controllercontext, controllerdescriptor, actionname);
if (actiondescriptor != null)
{
filterinfo filters = this.getfilters(controllercontext, actiondescriptor); 获取所有过滤器，全局的、控制器的和方法的
try
{
authenticationcontext authenticationcontext = this.invokeauthenticationfilters(controllercontext, filters.authenticationfilters, actiondescriptor);认证过滤器的执行。
if (authenticationcontext.result != null)
{
authenticationchallengecontext authenticationchallengecontext = this.invokeauthenticationfilterschallenge(controllercontext, filters.authenticationfilters, actiondescriptor, authenticationcontext.result);
this.invokeactionresult(controllercontext, authenticationchallengecontext.result ?? authenticationcontext.result);
}
else
{
authorizationcontext authorizationcontext = this.invokeauthorizationfilters(controllercontext, filters.authorizationfilters, actiondescriptor);授权过滤器的执行。
if (authorizationcontext.result != null)
{
authenticationchallengecontext authenticationchallengecontext2 = this.invokeauthenticationfilterschallenge(controllercontext, filters.authenticationfilters, actiondescriptor, authorizationcontext.result);
this.invokeactionresult(controllercontext, authenticationchallengecontext2.result ?? authorizationcontext.result);
}
else
{
if (controllercontext.controller.validaterequest)
{
controlleractioninvoker.validaterequest(controllercontext);
}
idictionary<string, object> parametervalues = this.getparametervalues(controllercontext, actiondescriptor); 获取方法执行参数。
actionexecutedcontext actionexecutedcontext = this.invokeactionmethodwithfilters(controllercontext, filters.actionfilters, actiondescriptor, parametervalues); 执行action，同时执行执行方法前后的 iacctionfilter
authenticationchallengecontext authenticationchallengecontext3 = this.invokeauthenticationfilterschallenge(controllercontext, filters.authenticationfilters, actiondescriptor, actionexecutedcontext.result);
this.invokeactionresultwithfilters(controllercontext, filters.resultfilters, authenticationchallengecontext3.result ?? actionexecutedcontext.result); 执行 actionresult，同时执行方法前后的 iresultfilter
}
}
}
catch (threadabortexception)
{
throw;
}
catch (exception exception)
{
exceptioncontext exceptioncontext = this.invokeexceptionfilters(controllercontext, filters.exceptionfilters, exception);
if (!exceptioncontext.exceptionhandled)
{
throw;
}
this.invokeactionresult(controllercontext, exceptioncontext.result);//异常过滤器的执行。
}
return true;
}
return false;
}
b、当选择完合适的action后，接着就是 modelbinder（默认是system.web.mvc.defaultmodelbinder），它会从http请求的参数中提取数据并实现类型转换，数据校验（例如是否必填，数据格式等）以及是否自动装配到action方法的参数中system.web.mvc.defaultmodelbinder
protected virtual idictionary<string, object> getparametervalues(controllercontext controllercontext, actiondescriptor actiondescriptor)
{
dictionary<string, object> dictionary = new dictionary<string, object>(stringcomparer.ordinalignorecase);
parameterdescriptor[] parameters = actiondescriptor.getparameters();
for (int i = 0; i < parameters.length; i++)
{
parameterdescriptor parameterdescriptor = parameters[i];
dictionary[parameterdescriptor.parametername] = this.getparametervalue(controllercontext, parameterdescriptor);
}
return dictionary;
}
protected virtual object getparametervalue(controllercontext controllercontext, parameterdescriptor parameterdescriptor)
{
type parametertype = parameterdescriptor.parametertype;
imodelbinder arg_92_0 = this.getmodelbinder(parameterdescriptor);
ivalueprovider valueprovider = controllercontext.controller.valueprovider;
string modelname = parameterdescriptor.bindinginfo.prefix ?? parameterdescriptor.parametername;
predicate<string> propertyfilter = controlleractioninvoker.getpropertyfilter(parameterdescriptor);
modelbindingcontext bindingcontext = new modelbindingcontext
{
fallbacktoemptyprefix = parameterdescriptor.bindinginfo.prefix == null,
modelmetadata = modelmetadataproviders.current.getmetadatafortype(null, parametertype),
modelname = modelname,
modelstate = controllercontext.controller.viewdata.modelstate,
propertyfilter = propertyfilter,
valueprovider = valueprovider
};
return arg_92_0.bindmodel(controllercontext, bindingcontext) ?? parameterdescriptor.defaultvalue;
}
c、authentication filter是mvc5中新增的一个filter，它会先于authorization filter执行，目的是对访问用户的认证。在mvc5之前，认证和授权都是通过authorization filter来实现的，但现在这2个操作就分开来了，各自管各自喽。
authenticationcontext authenticationcontext = this.invokeauthenticationfilters(controllercontext, filters.authenticationfilters, actiondescriptor);
if (authenticationcontext.result != null)
{
authenticationchallengecontext authenticationchallengecontext = this.invokeauthenticationfilterschallenge(controllercontext, filters.authenticationfilters, actiondescriptor, authenticationcontext.result);
this.invokeactionresult(controllercontext, authenticationchallengecontext.result ?? authenticationcontext.result);
}
d、action filters有2个方法onactionexecuting和onactionexecuted分别在action执行前后执行。我们也可以通过实现iactionfilter接口来实现你个性化的过滤机制
protected virtual actionexecutedcontext invokeactionmethodwithfilters(controllercontext controllercontext, ilist<iactionfilter> filters, actiondescriptor actiondescriptor, idictionary<string, object> parameters)
{
actionexecutingcontext precontext = new actionexecutingcontext(controllercontext, actiondescriptor, parameters);
func<actionexecutedcontext> seed = () => new actionexecutedcontext(controllercontext, actiondescriptor, false, null)
{
result = this.invokeactionmethod(controllercontext, actiondescriptor, parameters)
};
return filters.reverse<iactionfilter>().aggregate(seed, (func<actionexecutedcontext> next, iactionfilter filter) => () => controlleractioninvoker.invokeactionmethodfilter(filter, precontext, next))();
}
e、接下来就是执行我们平时在action方法中写的代码了（根据请求相应结果）
protected virtual actionresult invokeactionmethod(controllercontext controllercontext, actiondescriptor actiondescriptor, idictionary<string, object> parameters)
{
object actionreturnvalue = actiondescriptor.execute(controllercontext, parameters);
return this.createactionresult(controllercontext, actiondescriptor, actionreturnvalue);
}
（4）、actionresult 执行模块。
a、在 actionresult 执行前后，仍然会有一个filter（iresultfilter），同样的，通过实现 iresultfilter 接口你可以定制自己的过滤逻辑。
namespace system.web.mvc
{
/// <summary>defines the methods that are required for a result filter.</summary>
public interface iresultfilter
{
/// <summary>called before an action result executes.</summary>
/// <param name="filtercontext">the filter context.</param>
void onresultexecuting(resultexecutingcontext filtercontext);
/// <summary>called after an action result executes.</summary>
/// <param name="filtercontext">the filter context.</param>
void onresultexecuted(resultexecutedcontext filtercontext);
}
}
b、actionresult 就是把处理的用户请求结果返回。因此 viewresult, partialviewresult, redirecttorouteresult, redirectresult, contentresult, jsonresult, fileresult and emptyresult就是具体的返回类型。
c、上面的返回类型可以大致分为2类：viewresult 和非viewresult。对于需要生成html页面给客户端的划到viewresult，而其他的例如返回文本，json数据等则划分到非viewresult，对于非viewresult直接返回就可以了。
view的初始化和渲染呈现
a、对于 viewresult 最终是由合适的 view engine 通过调用 iview 的 render() 方法来渲染的：
namespace system.web.mvc
{
/// <summary>defines the methods that are required for a view engine.</summary>
public interface iviewengine
{
/// <summary>finds the specified partial view by using the specified controller context.</summary>
/// <returns>the partial view.</returns>
/// <param name="controllercontext">the controller context.</param>
/// <param name="partialviewname">the name of the partial view.</param>
/// <param name="usecache">true to specify that the view engine returns the cached view, if a cached view exists; otherwise, false.</param>
viewengineresult findpartialview(controllercontext controllercontext, string partialviewname, bool usecache);
/// <summary>finds the specified view by using the specified controller context.</summary>
/// <returns>the page view.</returns>
/// <param name="controllercontext">the controller context.</param>
/// <param name="viewname">the name of the view.</param>
/// <param name="mastername">the name of the master.</param>
/// <param name="usecache">true to specify that the view engine returns the cached view, if a cached view exists; otherwise, false.</param>
viewengineresult findview(controllercontext controllercontext, string viewname, string mastername, bool usecache);
/// <summary>releases the specified view by using the specified controller context.</summary>
/// <param name="controllercontext">the controller context.</param>
/// <param name="view">the view.</param>
void releaseview(controllercontext controllercontext, iview view);
}
}
namespace system.web.mvc
{
/// <summary>defines the methods that are required for a view.</summary>
public interface iview
{
/// <summary>renders the specified view context by using the specified the writer object.</summary>
/// <param name="viewcontext">the view context.</param>
/// <param name="writer">the writer object.</param>
void render(viewcontext viewcontext, textwriter writer);
}
}
b、整个处理过程是由 iviewengine 来实现的。asp.net mvc 默认提供 webform（.aspx）和 razor(.cshtml) 模板引擎，你可以通过实现 iviewengine 接口来实现自己的 viewengine，然后在application_start方法中做如下注册：
protected void application_start()
{
//移除所有的view引擎包括webform和razor
viewengines.engines.clear();
//注册你自己的view引擎
viewengines.engines.add(new customviewengine());
}
c、最后，html helpers将帮我们生成 input 标签，基于ajax的 form 等等。
（5）、作为总结，将每个节点主要的代码类贴出来。
这就是整个流程的代码节点，有些是同步执行，有些是异步执行，把握关键点，我这里只是谢了一个大概。
urlroutingmodule—–routecollection.getroutedata(context)—–>iroutehandler routehandler = routedata.routehandler——》ihttphandler httphandler = routehandler.gethttphandler(requestcontext)—–》context.remaphandler(httphandler)——->mvchandler——->processrequest()——>processrequestinit()——–》icontroller——>controller.execute(this.requestcontext)——–>controlleractioninvoker——->involeaction()———>involeactionmethod()——->involeactionreslt()
三、结束
今天就到这里了，东西虽然不多，但是也写了2个多小时。今天就算自己有学习了一边，大家一定要好好的把握这个流程，对于解决程序中的问题，扩展框架都有很大的好处。我们作为程序员的，应该要知道其一，也要知道其二。没事，看看源码，我们对框架和我们自己的代码有更深的了解。当然，这样做也是有代价的，需要更多的时间去支持，我相信我们的付出是值得。不忘初心，继续努力。老天不会辜负努力的人。
到此这篇关于详解asp.net mvc的整个生命周期的文章就介绍到这了,更多相关asp.net mvc 生命周期内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
