热门：网页模板.net视频教程JQueryMVCjsonExtJs源码示例三级联动JQuery菜单
您现在的位置：.Net中文社区>> .Net编程>>正文内容

深度解析ASP.NET2.0中的Callback机制

发布时间：2010年01月25日点击数： 次未知

callback的一般使用方法还算简单，直接参照msdn的帮助和范例就足够了。但是想要真正用好、用精，或者想开发一些基于callback机制的WEB组件，那么，就要先深入了解callback的实现机制了。在本文中，Teddy将和您一起解析callback的整个调用、反馈机制，相信对于帮助您更好的使用callback，将能有一定的益处。

　　Callback vs Atlas

　　首先，谈谈Atlas。很多朋友可能会觉得奇怪，已经有了Callback，为什么又要出Atlas呢？关于这个问题，Atlas的作者怎么解释，我倒没有去调查。只不过从我个人对callback和atlas的使用感受来讲，觉得，callback作为一个接口和postback非常类似的实现，肯定是为了让用户类似使用postback来使用它。但是，它的这个类似postback的机制，应该说使用上还不是特别方便，也不易扩展，当然这是相比于其他的AJAX框架实现来说的。因此，微软方面借鉴了许多的已有的AJAX实现，如Prototype，Backbase以及AJAX.NET，并结合ASP.NET2.0的部分特有功能，发明了这样一个博采众长的AJAX框架。基于Atlas来开发AJAX应用有多好，很难量化的来说，但至少不比其他的这些AJAX框架来的差是肯定的，加上微软这个后台，以及像live.com这样的重量级站点的应用推广，其影响当然是值得期待的。

　　不过，这也不是说callback实现没一无是处了，作为程序员，我们需要有正确的态度，在正确的使用情形，使用最正确的技术。没有哪一个框架是万能的，是适合任何使用环境的；就像大家都在争论那个软件开发方法最好，CMMi，RUP，XP，AGILE~~，其实，没有最好，最合适的才是最好的。我们最应该做的，是了解各种方案的原理和优缺点，从而，合理的使用正确的工具来解决实际问题。

　　Begin from Client Script

　　我们都知道，凡是AJAX，从底层来讲，无外乎两种实现机制：XMLHTTP以及IFRAME。在AJAX这个词获得广泛关注之前，其实，基于这两种底层实现的功能框架，或者基于这两种技术的无刷新效果实现就已经被广泛的使用了。当然，发展到今天，在使用接口方面，这些底层机制的细节往往被框架给隐藏了，使用接口变得越来越简单，用户只要调用这些简单接口，没有必要知道具体是怎么实现效果的了。

　　不过，这里我们既然是要解析callback的实现机制，那还是让我们从一个callback调用的客户端脚本调用开始，看看，微软是怎么实现这个callback机制的。

　　1、ClientScript.GetCallbackEventReference(...)

　　要激发一个callback，首先，当然需要在客户端本中发出一个调用。一个典型的调用语法如下： 

  1. ＜script language="javascript" type="text/javascript"＞   
  2. function any_script_function(arg, context)   
  3. {   
  4. 　＜%= ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context")%＞;   
  5. }   
  6. ＜/script＞   

ClientScript.GetCallbackEventReference(...)将根据传入的参数返回实际的回调脚本。这个函数有多个重载版本，因此，这些参数的含义，大家可以参考MSDN。以具体的上面这段示例代码中的参数来说：

　　- this表示执行回调的的服务端控件是当前这个Page，当前的Page必须实现ICallbackEventHandler接口，包括必须实现string GetCallbackResult()和void RaiseCallbackEvent(eventArgument)这两个接口函数，这个参数也可以是指向某个WEB控件的引用，当然，这个空间也必须实现ICallbackEventHandler接口；

　　- "arg"是将被传给RaiseCallbackEvent的参数eventArgument的值，可以使人以自定义格式的字符串；

　　- "ReceiveServerData"是当回调成功之后，处理返回内容的客户端脚本函数的名称，这个函数必须存在于执行回调的页面，并且这个函数可以包含两个参数，例如： 

  1. ＜script type="text/javascript"＞   
  2. function ReceiveServerData(result, context)   
  3. {}   
  4. ＜/script＞   

这两个参数，分别是回调的返回数据result，和原封不动被返回的我们激发回调时的这个context参数，当然，这两个参数都是字符串类型的。

　　- "context"就不用多解释了，记得这个参数会被原封不动的传给指定的返回数据处理函数就行了。MSDN的官方文档说，context一般可用来传递需要在客户端的返回数据处理函数中用来调用的脚本代码，不过实际上，你传什么都可以，把它看成一种从客户端回调的的激发端，到处理返回数据的接收段之间的参数传递通道就行了。

　　2、WebForm_DoCallback(...)

　　Ok，明白了以上代码的含义，下面我们来看看，前面的这条“＜%= ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context")%＞;”在运行时会被解析成什么样子呢？我们只要在页面运行时察看页面源码就可以看到，实际上服务器帮我们生成了下面这段script代码： 

  1. ＜script language="javascript" type="text/javascript"＞   
  2. function any_script_function()   
  3. {   
  4. 　WebForm_DoCallback(’__Page’,arg,ReceiveServerData,context,null,false);   
  5. }   
  6. ＜/script＞   

这段代码是什么意思呢？很显然的他调用了一个系统与定义的script函数：WebForm_DoCallback。我们要把这个函数找出来看看它具体为我们干了什么。在运行时的页面源码中，我们很容易可以找到这段脚本的出处。我们注意到有一个script，src="/TestCallbackWeb/WebResource.axd?d=HEcYmh-7_szSIu1D_mHSEw2&t=632661779991718750"，这里就定义了WebForm_DoCallback。让我们把它用flashget下载下来，将扩展名改为.js。看看源码吧，没有被混淆的，所以很容易看明白。我这里就只把和callback相关的部分贴出来解释一下，见代码中的注释： 

  1. //用于存放所有未完成的callback对象的数组__pendingCallbacks  
  2. var __pendingCallbacks = new Array();  
  3. var __synchronousCallBackIndex = -1;  
  4.  
  5. //回调主函数WebForm_DoCallback  
  6. function WebForm_DoCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {  
  7.  
  8. //构造回调参数，回调参数包括了原来页面上的formpostdata和我们传递的目标控件、eventArgument和部分验证信息  
  9. var postData = __theFormPostData +  
  10. "__CALLBACKID=" + WebForm_EncodeCallback(eventTarget) +  
  11. "&__CALLBACKPARAM=" + WebForm_EncodeCallback(eventArgument);  
  12. if (theForm["__EVENTVALIDATION"]) {  
  13. 　postData += "&__EVENTVALIDATION=" + WebForm_EncodeCallback(theForm["__EVENTVALIDATION"].value);  
  14. }  
  15.  
  16. //下面实例化XMLHTTP对象，如果浏览器支持XMLHTTP则直接用XMLHTTP执行异步回调  
  17. var xmlRequest,e;  
  18. try {  
  19. 　xmlRequest = new XMLHttpRequest();  
  20. }  
  21. catch(e) {  
  22. 　try {  
  23. 　　xmlRequest = new ActiveXObject("Microsoft.XMLHTTP");  
  24. 　}  
  25. 　catch(e) {}  
  26. }  
  27. var setRequestHeaderMethodExists = true;  
  28. try {  
  29. 　setRequestHeaderMethodExists = (xmlRequest && xmlRequest.setRequestHeader);  
  30. }  
  31. catch(e) {}  
  32. var callback = new Object();  
  33. callback.eventCallback = eventCallback;  
  34. callback.context = context;  
  35. callback.errorCallback = errorCallback;  
  36. callback.async = useAsync;  
  37.  
  38. //获取对应的回调对象   
  39. var callbackIndex = WebForm_FillFirstAvailableSlot(__pendingCallbacks, callback);  
  40. if (!useAsync) {  
  41. 　if (__synchronousCallBackIndex != -1) {  
  42. 　　__pendingCallbacks[__synchronousCallBackIndex] = null;  
  43. 　}  
  44. 　__synchronousCallBackIndex = callbackIndex;  
  45. }  
  46. if (setRequestHeaderMethodExists) {  
  47. 　xmlRequest.onreadystatechange = WebForm_CallbackComplete;  
  48. 　callback.xmlRequest = xmlRequest;  
  49. 　xmlRequest.open("POST", theForm.action, true);  
  50. 　xmlRequest.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");  
  51. 　xmlRequest.send(postData);  
  52. 　return;  
  53. }  
  54.  
  55. //万一浏览器不支持XMLHTTP的话，我们IFRAME方案代替，在一个隐藏的IFRAME中执行Postback   
  56. callback.xmlRequest = new Object();  
  57. var callbackFrameID = "__CALLBACKFRAME" + callbackIndex;  
  58. var xmlRequestFrame = document.frames[callbackFrameID];  
  59. if (!xmlRequestFrame) {  
  60. 　xmlRequestFrame = document.createElement("IFRAME");  
  61. 　xmlRequestFrame.width = "1";  
  62. 　xmlRequestFrame.height = "1";  
  63. 　xmlRequestFrame.frameBorder = "0";  
  64. 　xmlRequestFrame.id = callbackFrameID;  
  65. 　xmlRequestFrame.name = callbackFrameID;  
  66. 　xmlRequestFrame.style.position = "absolute";  
  67. 　xmlRequestFrame.style.top = "-100px"  
  68. 　xmlRequestFrame.style.left = "-100px";  
  69. 　try {  
  70. 　　if (callBackFrameUrl) {  
  71. 　　　xmlRequestFrame.src = callBackFrameUrl;  
  72. 　　}  
  73. 　}  
  74. 　catch(e) {}  
  75. 　document.body.appendChild(xmlRequestFrame);  
  76. }  
  77. var interval = window.setInterval(function() {  
  78. 　xmlRequestFrame = document.frames[callbackFrameID];  
  79. 　if (xmlRequestFrame && xmlRequestFrame.document) {  
  80. 　　window.clearInterval(interval);  
  81. 　　xmlRequestFrame.document.write("");  
  82. 　　xmlRequestFrame.document.close();  
  83. 　　xmlRequestFrame.document.write(’＜html＞＜body＞＜form method="post"＞＜input type="hidden" name="__CALLBACKLOADSCRIPT" value="t"＞＜/form＞＜/body＞＜/html＞’);  
  84. 　　xmlRequestFrame.document.close();  
  85. 　　xmlRequestFrame.document.forms[0].action = theForm.action;  
  86. 　　var count = __theFormPostCollection.length;  
  87. 　　var element;  
  88. 　　for (var i = 0; i ＜ count; i++) {  
  89. 　　　element = __theFormPostCollection[i];  
  90. 　　　if (element) {  
  91. 　　　　var fieldElement = xmlRequestFrame.document.createElement("INPUT");  
  92. 　　　　fieldElement.type = "hidden";  
  93. 　　　　fieldElement.name = element.name;  
  94. 　　　　fieldElement.value = element.value;  
  95. 　　　　xmlRequestFrame.document.forms[0].appendChild(fieldElement);  
  96. 　　　}  
  97. 　　}  
  98. 　　var callbackIdFieldElement = xmlRequestFrame.document.createElement("INPUT");  
  99. 　　callbackIdFieldElement.type = "hidden";  
  100. 　　callbackIdFieldElement.name = "__CALLBACKID";  
  101. 　　callbackIdFieldElement.value = eventTarget;  
  102. 　　xmlRequestFrame.document.forms[0].appendChild(callbackIdFieldElement);  
  103. 　　var callbackParamFieldElement = xmlRequestFrame.document.createElement("INPUT");  
  104. 　　callbackParamFieldElement.type = "hidden";  
  105. 　　callbackParamFieldElement.name = "__CALLBACKPARAM";  
  106. 　　callbackParamFieldElement.value = eventArgument;  
  107. 　　xmlRequestFrame.document.forms[0].appendChild(callbackParamFieldElement);  
  108. 　　if (theForm["__EVENTVALIDATION"]) {  
  109. 　　　var callbackValidationFieldElement = xmlRequestFrame.document.createElement("INPUT");  
  110. 　　　callbackValidationFieldElement.type = "hidden";  
  111. 　　　callbackValidationFieldElement.name = "__EVENTVALIDATION";  
  112. 　　　callbackValidationFieldElement.value = theForm["__EVENTVALIDATION"].value;  
  113. 　　　xmlRequestFrame.document.forms[0].appendChild(callbackValidationFieldElement);  
  114. 　　}  
  115. 　　var callbackIndexFieldElement = xmlRequestFrame.document.createElement("INPUT");  
  116. 　　callbackIndexFieldElement.type = "hidden";  
  117. 　　callbackIndexFieldElement.name = "__CALLBACKINDEX";  
  118. 　　callbackIndexFieldElement.value = callbackIndex;  
  119. 　　xmlRequestFrame.document.forms[0].appendChild(callbackIndexFieldElement);  
  120. 　　xmlRequestFrame.document.forms[0].submit();  
  121. 　}  
  122. }, 10);  
  123. }  
  124.  
  125. //该函数在每次回调结束后会调用来检查当前的回调列表中的回调的执行情况，如果，执行完毕的，则从列表中删除回调对象，并删除临时建立的IFRAME  
  126. function WebForm_CallbackComplete() {  
  127. 　for (i = 0; i ＜ __pendingCallbacks.length; i++) {  
  128. 　　callbackObject = __pendingCallbacks[i];  
  129. 　　if (callbackObject && callbackObject.xmlRequest && (callbackObject.xmlRequest.readyState == 4)) {  
  130. 　　　WebForm_ExecuteCallback(callbackObject);  
  131. 　　　if (!__pendingCallbacks[i].async) {  
  132. 　　　　__synchronousCallBackIndex = -1;  
  133. 　　　}  
  134. 　　　__pendingCallbacks[i] = null;  
  135. 　　　var callbackFrameID = "__CALLBACKFRAME" + i;  
  136. 　　　var xmlRequestFrame = document.getElementById(callbackFrameID);  
  137. 　　　if (xmlRequestFrame) {  
  138. 　　　　xmlRequestFrame.parentNode.removeChild(xmlRequestFrame);  
  139. 　　　}  
  140. 　　}  
  141. 　}  
  142. }  
  143.  
  144. //该函数执行我们在回调激发端指定的处理返回数据的script函数，如我们上面范例代码中的ReceiveServerData函数  
  145. function WebForm_ExecuteCallback(callbackObject) {  
  146. 　var response = callbackObject.xmlRequest.responseText;  
  147. 　if (response.charAt(0) == "s") {  
  148. 　　if ((typeof(callbackObject.eventCallback) != "undefined") && (callbackObject.eventCallback != null)) {  
  149. 　　　callbackObject.eventCallback(response.substring(1), callbackObject.context);  
  150. 　　}  
  151. 　}  
  152. 　else if (response.charAt(0) == "e") {  
  153. 　　if ((typeof(callbackObject.errorCallback) != "undefined") && (callbackObject.errorCallback != null)) {  
  154. 　　　callbackObject.errorCallback(response.substring(1), callbackObject.context);  
  155. 　　}  
  156. 　}  
  157. 　else {  
  158. 　　var separatorIndex = response.indexOf("|");  
  159. 　　if (separatorIndex != -1) {  
  160. 　　　var validationFieldLength = parseInt(response.substring(0, separatorIndex));  
  161. 　　　if (!isNaN(validationFieldLength)) {  
  162. 　　　　var validationField = response.substring(separatorIndex + 1, separatorIndex + validationFieldLength + 1);  
  163. 　　　　if (validationField != "") {  
  164. 　　　　　var validationFieldElement = theForm["__EVENTVALIDATION"];  
  165. 　　　　　if (!validationFieldElement) {  
  166. 　　　　　　validationFieldElement = document.createElement("INPUT");  
  167. 　　　　　　validationFieldElement.type = "hidden";  
  168. 　　　　　　validationFieldElement.name = "__EVENTVALIDATION";  
  169. 　　　　　　theForm.appendChild(validationFieldElement);  
  170. 　　　　　}  
  171. 　　　　　validationFieldElement.value = validationField;  
  172. 　　　　}  
  173. 　　　　if ((typeof(callbackObject.eventCallback) != "undefined") && (callbackObject.eventCallback != null)) {  
  174. 　　　　　callbackObject.eventCallback(response.substring(separatorIndex + validationFieldLength + 1), 　　　　　　　　callbackObject.context);  
  175. 　　　　}  
  176. 　　　}  
  177. 　　}  
  178. 　}  
  179. }  
  180.  
  181. //获取对应的回调对象   
  182. function WebForm_FillFirstAvailableSlot(array, element) {  
  183. 　var i;  
  184. 　for (i = 0; i ＜ array.length; i++) {  
  185. 　　if (!array[i]) break;  
  186. 　}  
  187. 　array[i] = element;  
  188. 　return i;  
  189. }  
  190.  
  191. //再下面是一些辅助函数和与callback关系不大的函数，我就不列出来了，有兴趣的朋友可以自己看看  
  192. //  

从以上代码我们可以很明白的看到，系统判断您的浏览器是否支持XMLHTTP或IFRAME，如果至少支持其中之一，则用相应的方法执行回调，否则当然就是提示错误了。回调的时候，采用post的方式，异步post到当前页面，然后等待回调结束，此时，由我们指定的返回数据处理script函数来处理返回的数据。

　　看到这里，我还不知道服务端怎么处理这个根据传过来的参数解析、执行，并返回数据的过程。但是，我们已经知道，WebForm_DoCallback(...)将会将当前页面的web控件的信息都post回去，这就意味着，我们在服务端有可能可以访问到这些web控件的value，这还不错，方便了我们处理当前数据。另一方面，eventArgument既然是一个任意格式的字符串参数，我们肯定要在服务段自己解析它的。

　　Serverside Callback Operation & Render

　　好了，那么接下来就让我们来看看在服务端，ASP.NET都为我们做了些什么。

　　首先，我们知道，当前的Page是必须实现ICallbackEventHandler这个接口的，也就是其包含的两个函数：string GetCallbackResult()和void RaiseCallbackEvent(eventArgument)。根据MSDN的文档，我们知道，在一个callback被post到服务端时，Page将会首先将post回来的form data绑定到当前页面的服务端web控件，接着判断本次post是callback还是postback，如果是postpost，那么自然是原来的那个机制；

　　如果是callback，则将回调用触发本次callback的控件（在本例中，我们在激发这个callback时，第一个参数指定的是this也就是当前的Page，那么这里当前的Page就是这个触发控件）的RaiseCallbackEvent(eventArgument)，当然，eventArgument也将会正确的传过来，在这个函数的实现代码里我们可以对这个参数进行解析处理，并在某个地方，存储我们准备返回的数据，或者待处理的已经被解析出来的参数。

　　接着，系统将调用string GetCallbackResult()，在这个函数的实现代码中，我们可以直接返回我们在RaiseCallback函数中存储的准备返回的数据，或者根据待处理的已经被解析出来的参数处理这些参数，并返回结果。这个返回的字符串，自然将以脚本的形式被render回客户端。被返回的脚本细节如下(反编译Page.RenderCallback()的源码)，我们可以看到，返回的结果除了我们需要的结果数据和相应的脚本，没有多余的数据，因此，callback的执行效率应该说还是不错的：

  1. private void RenderCallback()  
  2. {  
  3. 　bool flag1 = !string.IsNullOrEmpty(this._requestValueCollection["__CALLBACKLOADSCRIPT"]);  
  4. 　try  
  5. 　{  
  6. 　　string text1 = null;  
  7. 　　if (flag1)  
  8. 　　{  
  9. 　　　text1 = this._requestValueCollection["__CALLBACKINDEX"];  
  10. 　　　if (string.IsNullOrEmpty(text1))  
  11. 　　　{  
  12. 　　　　throw new HttpException(SR.GetString("Page_CallBackInvalid"));  
  13. 　　　}  
  14. 　　　for (int num1 = 0; num1 ＜ text1.Length; num1++)  
  15. 　　　{  
  16. 　　　　if (!char.IsDigit(text1, num1))  
  17. 　　　　{  
  18. 　　　　　throw new HttpException(SR.GetString("Page_CallBackInvalid"));  
  19. 　　　　}  
  20. 　　　}  
  21. 　　　this.Response.Write("＜script＞parent.__pendingCallbacks[");  
  22. 　　　this.Response.Write(text1);  
  23. 　　　this.Response.Write("].xmlRequest.responseText=\"");  
  24. 　　}  
  25. 　　if (this._callbackControl != null)  
  26. 　　{  
  27. 　　　string text2 = this._callbackControl.GetCallbackResult();  
  28. 　　　if (this.EnableEventValidation)  
  29. 　　　{  
  30. 　　　　string text3 = this.ClientScript.GetEventValidationFieldValue();  
  31. 　　　　this.Response.Write(text3.Length.ToString(CultureInfo.InvariantCulture));  
  32. 　　　　this.Response.Write(’|’);  
  33. 　　　　this.Response.Write(text3);  
  34. 　　　}  
  35. 　　　else  
  36. 　　　{  
  37. 　　　　this.Response.Write(’s’);  
  38. 　　　}  
  39. 　　　this.Response.Write(flag1 ? Util.QuoteJScriptString(text2) : text2);  
  40. 　　}  
  41. 　　if (flag1)  
  42. 　　{  
  43. 　　　this.Response.Write("\";parent.__pendingCallbacks[");  
  44. 　　　this.Response.Write(text1);  
  45. 　　　this.Response.Write("].xmlRequest.readyState=4;parent.WebForm_CallbackComplete();＜/script＞");  
  46. 　　}  
  47. 　}  
  48. 　catch (Exception exception1)  
  49. 　{  
  50. 　　this.Response.Clear();  
  51. 　　this.Response.Write(’e’);  
  52. 　　if (this.Context.IsCustomErrorEnabled)  
  53. 　　{  
  54. 　　　this.Response.Write(SR.GetString("Page_CallBackError"));  
  55. 　　　return;  
  56. 　　}  
  57. 　　this.Response.Write(flag1 ? Util.QuoteJScriptString(HttpUtility.HtmlEncode(exception1.Message)) : 　HttpUtility.HtmlEncode(exception1.Message));  
  58. 　}  
  59. }  

另外，才发现原来System.Web.UI.Utils这个类中有那么多有用的方便的函数如QuateJScriptString()，以前一直自己手写这样功能的函数呢~~真傻呀~~

　　Conclusion

　　至此，我们已经基本上清楚明白callback的前台幕后了。如果您对服务段的处理过程的细节还觉得不够，您也可以自行反编译Page对象，看看其实现代码的细节，还是很有意思的。

　　总体而言，我们发现，callback无论是兼容性（XMLHTTP或IFRAME我想大多数浏览器都支持吧），还是性能（没有返回不需要的数据），还是使用的便利性（因为ASP.NET帮我们绑定了页面上的当前的Web控件的数据，这就意味着我们可以在callback后的服务端，象postback时一样来写代码，也方便我们移植原来的postback的代码到callback方式的代码）都是非常优秀的。我们也完全可以扩展现有的控件，或者写我们自己的控件以支持这样的callback效果，并且，混合使用callback控件和原来的postback方式的控件也是非常可靠和容易的。这对我们升级原来的基于postback为主的代码，是非常有利的，如果用Atlas来做同样的代码升级和与postback方式的控件混合使用，我可以跟您说，会有很多问题。不信你自己可以试试。 

随机文章推荐

本站热点业务

更多模板/案例展示

热门推荐

最近更新

关于我们 | 联系我们 | 团队日志 | 网站地图 | 网站合作
本站部份资源来于互联网,只供学习之用,不得用于商业,如有侵犯版权请联系告知,本站将第一时间删除!
copyright © 2008-2010 .Net中文社区 ASPXCS.NET™.All Rights Reserved 滇ICP备08102132号