ASP.NETWebForm也可以这样用Ajax

对于asp.net WebForm项目，进行Ajax操作大概有三种方式：web服务（.asmx文件）  ,  一般处理程序（.ashx）和  一些Ajax控件。

对于.net提供的ajax控件，暂且不说，只说另外两种方式，都需要引入额外的代码文件对Ajax进行操作（asmx和ashx，且web服务还要引入一个cs文件与之对应）,假如要对Example.aspx这个页面添加一些自定义的Ajax操作，并且这些Ajax操作并不会在别的页面上用到，如此不得不引入额外的代码文件完成这个操作，假如这个Ajax操作很简单，只需要一个简单的函数就可以执行，那岂不是很麻烦的过程吗？如此一来，随着项目中 Ajax操作的增多，ashx和asmx文件都会随着时间的增长而增长，项目的维护也会随之加倍。为什么我们不能把Ajax操作的后台代码直接放在 Example.aspx对应的Example.aspx.cs文件里 ? 如果能这样做，以上两种烦恼都会迎刃而解，不是吗？

于是，按照以上思路，实现了如下Ajax框架。先来看这个框架的实现机制：

上图是自己画的一个缩减版IIS接收到一个aspx请求的HttpApplication管线和asp.net Page在执行ProcessRequest（）方法中的页面生命周期的部分事件。Page本身是继承自IHttpHandler接口，IHttpHandler提供了一个重要的约束方法ProcessRequest，该方法是对接收到的信息（HttpContext）进行具体的处理同样，一般处理程序和web服务也实现了自己的IHttpHandler，并以此提供一些Ajax服务。具体的操作过程请自行查找MSDN。

原理是在页面生命周期开始的第一个事件PreInit进行一些处理，一旦发现劫持到的请求是一个ajax请求，那么利用C#的反射来调用aspx.cs中定义的方法，执行完方法之后，调用Response.End()方法，调用这个方法会直接跳到管线的EndRequest事件，从而结束请求，这样就无需走一些没有必要的页面生命周期的步骤，从而完成一个Ajax操作。如果发现是一个正常的操作，那么就走正常流程。

下面以一个简单例子说明该Ajax框架的使用：

1. 添加一个解决方案

2. 新建一个 Default.aspx 页面

3. 在Default.aspx.cs页面中创建一个被调用的测试方法：

 
 
 
 
    
  
  
  
  
  1. public List  TestAjaxMethod(int a, string b, float c)  
    2.   
  
  
  
  2.         {  
    3.   
  
  
  
  3.                return new List { a.ToString(), b, c.ToString() };  
    4.   
  
  
  
  4.         } 
    5.

4.      在Default.aspx中写一个Ajax请求

 
 
 
 
    
  
  
  
  
  1. PowerAjax.AsyncAjax(‘TestAjaxMethod’, [1, 2, "333","sss"], function (SucceessResponse) {  
    2.   
  
  
  
  2.         // 成功后的代码  
    3.   
  
  
  
  3. }); 
    4.

PowerAjax.js是用Jquery专门为这个框架封装的一个及其简单的JS类库，这个类库中有两个主要的方法：PowerAjax.AsyncAjax和PowerAjax.SyncAjax，一个提供同步操作，一个提供异步操作，参数有三个：

第一个参数是即将操作在aspx.cs的Ajax方法的名字（用名字反射方法）。

第二个参数是一个以数组形式组成参数列表数据。

第三个参数是操作成功之后执行执行的回调方法，与c#中的委托一个道理。

以下为这个简单JS库的代码：

 
 
 
 
    
  
  
  
  
  1. var PowerAjax = function () { }  
    2.   
  
  
  
  2. PowerAjax.__Private = function () { }  
    3.   
  
  
  
  3.    
    4.   
  
  
  
  4. // 进行异步操作  
    5.   
  
  
  
  5. PowerAjax.AsyncAjax = function (methodName, paramArray, success) {  
    6.   
  
  
  
  6.     PowerAjax.__Private.Ajax(methodName, paramArray, success, true);  
    7.   
  
  
  
  7. }  
    8.   
  
  
  
  8.    
    9.   
  
  
  
  9. // 进行的是同步操作  
    10.   
  
  
  
  10. PowerAjax.SyncAjax = function (methodName, paramArray, success) {  
    11.   
  
  
  
  11.     PowerAjax.__Private.Ajax(methodName, paramArray, success, false);  
    12.   
  
  
  
  12. }  
    13.   
  
  
  
  13.    
    14.   
  
  
  
  14. PowerAjax.__Private.Ajax = function (methodName, paramArray, success, isAsync) {  
    15.   
  
  
  
  15.     var data = {};  
    16.   
  
  
  
  16.     switch (paramArray.length) {  
    17.   
  
  
  
  17.         case 0:  
    18.   
  
  
  
  18.             data = { 'isAjaxRequest': true, 'MethodName': methodName };  
    19.   
  
  
  
  19.             break;  
    20.   
  
  
  
  20.         case 1:  
    21.   
  
  
  
  21.             data = { 'isAjaxRequest': true, 'MethodName': methodName, "param0": paramArray[0] };  
    22.   
  
  
  
  22.             break;  
    23.   
  
  
  
  23.         case 2:  
    24.   
  
  
  
  24.             data = { 'isAjaxRequest': true, 'MethodName': methodName, "param0": paramArray[0], "param1": paramArray[1] };  
    25.   
  
  
  
  25.             break;  
    26.   
  
  
  
  26.         case 3:  
    27.   
  
  
  
  27.             data = { 'isAjaxRequest': true, 'MethodName': methodName, "param0": paramArray[0], "param1": paramArray[1], "param2": paramArray[2] };  
    28.   
  
  
  
  28.             break;  
    29.   
  
  
  
  29.         case 4:  
    30.   
  
  
  
  30.             data = { 'isAjaxRequest': true, 'MethodName': methodName, "param0": paramArray[0], "param1": paramArray[1], "param2": paramArray[2], "param3": paramArray[3] };  
    31.   
  
  
  
  31.             break;  
    32.   
  
  
  
  32.         case 5:  
    33.   
  
  
  
  33.             data = { 'isAjaxRequest': true, 'MethodName': methodName, "param0": paramArray[0], "param1": paramArray[1], "param2": paramArray[2], "param3": paramArray[3], "param4": paramArray[4] };  
    34.   
  
  
  
  34.             break;  
    35.   
  
  
  
  35.     }  
    36.   
  
  
  
  36.    
    37.   
  
  
  
  37.     var url = document.location.href;  
    38.   
  
  
  
  38.     $.ajax({  
    39.   
  
  
  
  39.         type: "post",  
    40.   
  
  
  
  40.         url: url,  
    41.   
  
  
  
  41.         data: data,  
    42.   
  
  
  
  42.         async: isAsync,  
    43.   
  
  
  
  43.         datatype: "json",  
    44.   
  
  
  
  44.         contentType: "application/x-www-form-urlencoded; charset=UTF-8",  
    45.   
  
  
  
  45.         success: function (response) {  
    46.   
  
  
  
  46.             success(response);  
    47.   
  
  
  
  47.         },  
    48.   
  
  
  
  48.         error: function (response) {  
    49.   
  
  
  
  49.             if (response.status == 500) {  
    50.   
  
  
  
  50.                 var errorMessage = response.responseText;  
    51.   
  
  
  
  51.                 var errorTitle = errorMessage.substring(errorMessage.indexOf("") + 7, errorMessage.indexOf(""))  
    52.   
  
  
  
  52.                 throw new Error("服务器内部错误：" + errorTitle);  
    53.   
  
  
  
  53.             }  
    54.   
  
  
  
  54.         }  
    55.   
  
  
  
  55.     });  
    56.   
  
  
  
  56. } 
    57.

5. 更改Default.aspx.cs的继承页面为AjaxBasePage              

 
 
 
 
    
  
  
  
  
  1. public partial class _Default : AjaxBasePage 
    2.

#p#

6. 主要基类：AjaxBasePage类

如下代码：

 
 
 
 
    
  
  
  
  
  1. public class AjaxBasePage : System.Web.UI.Page  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     ///   
    4.   
  
  
  
  4.     /// 是否是一个ajax请求。  
    5.   
  
  
  
  5.     ///   
    6.   
  
  
  
  6.     public bool IsAjaxRequest { get; private set; }  
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     ///   
    9.   
  
  
  
  9.     ///  如果是Ajax请求，劫持页面生命周期的PreInit的事件，直接返回Response  
    10.   
  
  
  
  10.     ///   
    11.   
  
  
  
  11.     protected override void OnPreInit(EventArgs e)  
    12.   
  
  
  
  12.     {  
    13.   
  
  
  
  13.         AjaxRequest ajaxRequest = AjaxRequest.GetInstance(Request.Form);  
    14.   
  
  
  
  14.         this.IsAjaxRequest = ajaxRequest.IsAjaxRequest;  
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         if (this.IsAjaxRequest)  
    17.   
  
  
  
  17.         {  
    18.   
  
  
  
  18.             AjaxApplication ajaxApplication = new AjaxApplication(this, ajaxRequest);  
    19.   
  
  
  
  19.             ajaxApplication.EndRequest();  
    20.   
  
  
  
  20.         }  
    21.   
  
  
  
  21.         else 
    22.   
  
  
  
  22.         {  
    23.   
  
  
  
  23.             // 如果不是Ajax请求，继续执行页面生命周期的剩余事件  
    24.   
  
  
  
  24.             base.OnPreInit(e);  
    25.   
  
  
  
  25.         }  
    26.   
  
  
  
  26.     }  
    27.   
  
  
  
  27. } 
    28.

该类重写了PreInit方法，判断请求是否是一个Ajax请求。通过AjaxRequest类接收并处理接收到的请求，提取出一些有效的数据，比如说是否是一个Ajax请求，方法的名字，参数列表（AjaxParameter类）。

至于AjaxParameter类，内部用的数据结构其实是一个字典，并使用索引来提供对数据的方便访问，提供一个Count属性，方便获取参数的个数。     如下代码

 
 
 
 
    
  
  
  
  
  1. public class AjaxParameter  
    2.   
  
  
  
  2.     {  
    3.   
  
  
  
  3.         private IDictionary m_DictionaryParamsData = new Dictionary();  
    4.   
  
  
  
  4.    
    5.   
  
  
  
  5.         ///   
    6.   
  
  
  
  6.         /// 返回参数的个数。  
    7.   
  
  
  
  7.         ///   
    8.   
  
  
  
  8.         public int Count  
    9.   
  
  
  
  9.         {  
    10.   
  
  
  
  10.             get  
    11.   
  
  
  
  11.             {  
    12.   
  
  
  
  12.                 return this.m_DictionaryParamsData.Count;  
    13.   
  
  
  
  13.             }  
    14.   
  
  
  
  14.         }  
    15.   
  
  
  
  15.    
    16.   
  
  
  
  16.         ///   
    17.   
  
  
  
  17.         /// 索引具体参数的值。  
    18.   
  
  
  
  18.         ///   
    19.   
  
  
  
  19.         ///   
    20.   
  
  
  
  20.         ///   
    21.   
  
  
  
  21.         public string this[int index]  
    22.   
  
  
  
  22.         {  
    23.   
  
  
  
  23.             get  
    24.   
  
  
  
  24.             {  
    25.   
  
  
  
  25.                 if (index >= 5 || index < 0)  
    26.   
  
  
  
  26.                 {  
    27.   
  
  
  
  27.                     throw new NotSupportedException("请求方法的参数的个数限制为：0-5");  
    28.   
  
  
  
  28.                 }  
    29.   
  
  
  
  29.                 return this.m_DictionaryParamsData[index];  
    30.   
  
  
  
  30.             }  
    31.   
  
  
  
  31.         }  
    32.   
  
  
  
  32.    
    33.   
  
  
  
  33.         public AjaxParameter(IDictionary paramsData)  
    34.   
  
  
  
  34.         {  
    35.   
  
  
  
  35.             this.m_DictionaryParamsData = paramsData;  
    36.   
  
  
  
  36.         }  
    37.   
  
  
  
  37.     } 
    38.

 AjaxRequest类的设计思路其实是模仿HttpContext设计，HttpContext能够从基础的http请求报文分析出以后处理将要用到的数据（response，request，session，cookie等等）数据，而AjaxRequest通过分析Ajax的Post请求的数据域 Data分析出各种以后会用到的数据。如下是该类的代码：

 
 
 
 
    
  
  
  
  
  1. public class AjaxRequest  
    2.   
  
  
  
  2.     {  
    3.   
  
  
  
  3.         private Dictionary m_DictionaryParamsData = new Dictionary();  
    4.   
  
  
  
  4.         private AjaxParameter m_AjaxParameter;  
    5.   
  
  
  
  5.         private int m_Count = 0;  
    6.   
  
  
  
  6.    
    7.   
  
  
  
  7.         #region 属性  
    8.   
  
  
  
  8.         ///   
    9.   
  
  
  
  9.         /// 是否是一个Ajax请求。  
    10.   
  
  
  
  10.         ///   
    11.   
  
  
  
  11.         public bool IsAjaxRequest { get; private set; }  
    12.   
  
  
  
  12.    
    13.   
  
  
  
  13.         ///   
    14.   
  
  
  
  14.         /// 请求的方法名字。  
    15.   
  
  
  
  15.         ///   
    16.   
  
  
  
  16.         public string MethodName { get; private set; }  
    17.   
  
  
  
  17.    
    18.   
  
  
  
  18.         ///   
    19.   
  
  
  
  19.         /// 参数数据。  
    20.   
  
  
  
  20.         ///   
    21.   
  
  
  
  21.         public AjaxParameter Parameters  
    22.   
  
  
  
  22.         {  
    23.   
  
  
  
  23.             get { return this.m_AjaxParameter; }  
    24.   
  
  
  
  24.         }  
    25.   
  
  
  
  25.         #endregion  
    26.   
  
  
  
  26.    
    27.   
  
  
  
  27.         #region 构造函数  
    28.   
  
  
  
  28.         private AjaxRequest(NameValueCollection nameValueCollection)  
    29.   
  
  
  
  29.         {  
    30.   
  
  
  
  30.             this.IsAjaxRequest = nameValueCollection["isAjaxRequest"] == "true";  
    31.   
  
  
  
  31.             if (this.IsAjaxRequest)  
    32.   
  
  
  
  32.             {  
    33.   
  
  
  
  33.                 this.MethodName = nameValueCollection["MethodName"];  
    34.   
  
  
  
  34.    
    35.   
  
  
  
  35.                 foreach (string value in nameValueCollection)  
    36.   
  
  
  
  36.                 {  
    37.   
  
  
  
  37.                     string formKey = string.Format("param{0}", this.m_Count);  
    38.   
  
  
  
  38.                     if (nameValueCollection[formKey] != null)  
    39.   
  
  
  
  39.                     {  
    40.   
  
  
  
  40.                         this.m_DictionaryParamsData.Add(this.m_Count, nameValueCollection[formKey]);  
    41.   
  
  
  
  41.                         this.m_Count++;  
    42.   
  
  
  
  42.                     }  
    43.   
  
  
  
  43.                 }  
    44.   
  
  
  
  44.                 m_AjaxParameter = new AjaxParameter(this.m_DictionaryParamsData);  
    45.   
  
  
  
  45.             }  
    46.   
  
  
  
  46.         }  
    47.   
  
  
  
  47.    
    48.   
  
  
  
  48.         #endregion  
    49.   
  
  
  
  49.    
    50.   
  
  
  
  50.         #region 实例方法  
    51.   
  
  
  
  51.         public static AjaxRequest GetInstance(NameValueCollection nameValueCollection)  
    52.   
  
  
  
  52.         {  
    53.   
  
  
  
  53.             return new AjaxRequest(nameValueCollection);  
    54.   
  
  
  
  54.         }  
    55.   
  
  
  
  55.         #endregion  
    56.   
  
  
  
  56.    
    57.   
  
  
  
  57.         #region ToString  
    58.   
  
  
  
  58.         public override string ToString()  
    59.   
  
  
  
  59.         {  
    60.   
  
  
  
  60.             return this.MethodName;  
    61.   
  
  
  
  61.         }  
    62.   
  
  
  
  62.         #endregion  
    63.   
  
  
  
  63.     } 
    64.

通过分析AjaxRequest的属性IsAjaxRequest可判断是否为Ajax请求，若该请求为一个Ajax请求，那么创建一个AjaxApplication实例，在创建AjaxApplication实例的过程中会利用当前页面和AjaxRequest提供的数据进行实际方法的调用（反射），该类是执行Ajax方法的核心类，其中会判断是否读取的到的方法是一个有效的方法，并判断从JS中AjaxApplication传入的参数类型的有效性，目前只提供对以下13中参数提供支持，如下：

 
 
 
 
    
  
  
  
  
  1. （String、Boolean、Int32、Int64、UInt32、UInt64、Single、Double、Decimal、DateTime、DateTimeOffset、TimeSpan、Guid） 
    2.

如果方法中出现非以上类型，将会抛出异常。为了方便Ajax的调试，在JS前段类库中我会对异常进行处理，并抛出Error，Error信息有效的截取了继承自Exception的抛出信息，至于如何获    得更加详细的JS调试信息，以后JS库中可能会做提供更加详细的调用信息，毕竟框架是在改进中进行的。如下是AjaxApplication类的具体代码：

 
 
 
 
    
  
  
  
  
  1. public class AjaxApplication  
    2.   
  
  
  
  2.     {  
    3.   
  
  
  
  3.         private AjaxBasePage m_AjaxBasePage;  
    4.   
  
  
  
  4.         private object m_ResponseData;  
    5.   
  
  
  
  5.    
    6.   
  
  
  
  6.         public AjaxApplication(AjaxBasePage ajaxBasePage, AjaxRequest ajaxRequest)  
    7.   
  
  
  
  7.         {  
    8.   
  
  
  
  8.             this.m_AjaxBasePage = ajaxBasePage;  
    9.   
  
  
  
  9.             Type ajaxBasePageType = ajaxBasePage.GetType();  
    10.   
  
  
  
  10.             MethodInfo methodInfo = ajaxBasePageType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)  
    11.   
  
  
  
  11.                                         .FirstOrDefault(item => item.Name == ajaxRequest.MethodName);  
    12.   
  
  
  
  12.             object[] parameterData = this.GetParameterData(ajaxRequest, methodInfo);  
    13.   
  
  
  
  13.    
    14.   
  
  
  
  14.             if (methodInfo.IsStatic)  
    15.   
  
  
  
  15.             {  
    16.   
  
  
  
  16.                 this.m_ResponseData = methodInfo.Invoke(null, parameterData);  
    17.   
  
  
  
  17.             }  
    18.   
  
  
  
  18.             else 
    19.   
  
  
  
  19.             {  
    20.   
  
  
  
  20.                 this.m_ResponseData = methodInfo.Invoke(ajaxBasePage, parameterData);  
    21.   
  
  
  
  21.             }  
    22.   
  
  
  
  22.         }  
    23.   
  
  
  
  23.    
    24.   
  
  
  
  24.         ///   
    25.   
  
  
  
  25.         /// 获取参数数据。  
    26.   
  
  
  
  26.         ///   
    27.   
  
  
  
  27.         private object[] GetParameterData(AjaxRequest ajaxRequest, MethodInfo methodInfo)  
    28.   
  
  
  
  28.         {  
    29.   
  
  
  
  29.             if (methodInfo != null)  
    30.   
  
  
  
  30.             {  
    31.   
  
  
  
  31.                 ParameterInfo[] parameterInfos = methodInfo.GetParameters();  
    32.   
  
  
  
  32.    
    33.   
  
  
  
  33.                 if (parameterInfos.Length > 5)  
    34.   
  
  
  
  34.                 {  
    35.   
  
  
  
  35.                     throw new NotSupportedException("最多支持5个参数");  
    36.   
  
  
  
  36.                 }  
    37.   
  
  
  
  37.    
    38.   
  
  
  
  38.                 if (parameterInfos.Length > ajaxRequest.Parameters.Count)  
    39.   
  
  
  
  39.                 {  
    40.   
  
  
  
  40.                     throw new ArgumentException("缺少参数!");  
    41.   
  
  
  
  41.                 }  
    42.   
  
  
  
  42.    
    43.   
  
  
  
  43.                 List parameterData = new List(parameterInfos.Length);    
  
  
  
  44.                 for (int i = 0; i < parameterInfos.Length; i++)  
    45.   
  
  
  
  45.                 {  
    46.   
  
  
  
  46.                     ParameterInfo parameterInfo = parameterInfos[i];  
    47.   
  
  
  
  47.                     string paramValue = ajaxRequest.Parameters[i];  
    48.   
  
  
  
  48.    
    49.   
  
  
  
  49.                     try 
    50.   
  
  
  
  50.                     {  
    51.   
  
  
  
  51.                         parameterData.Add(ParseAjaxParameter(paramValue, parameterInfo));  
    52.   
  
  
  
  52.                     }  
    53.   
  
  
  
  53.                     catch (FormatException)  
    54.   
  
  
  
  54.                     {  
    55.   
  
  
  
  55.                         string format = string.Format("传入静态方法 {0} 的第 {1} 个（从0开始计数）参数类型不匹配，应该为 {2} 类型 请检查！", methodInfo.Name, i, parameterInfo.ParameterType.Name);  
    56.   
  
  
  
  56.                         throw new FormatException(format);  
    57.   
  
  
  
  57.                     }  
    58.   
  
  
  
  58.                 }  
    59.   
  
  
  
  59.                 return parameterData.ToArray();  
    60.   
  
  
  
  60.             }  
    61.   
  
  
  
  61.             else 
    62.   
  
  
  
  62.             {  
    63.   
  
  
  
  63.                 throw new InvalidOperationException("没有发现此方法，请检查该方法签名（方法必须为public）");  
    64.   
  
  
  
  64.             }  
    65.   
  
  
  
  65.         }  
    66.   
  
  
  
  66.    
    67.   
  
  
  
  67.         ///   
    68.   
  
  
  
  68.         /// 类型转换。支持 String、Boolean、Int32、Int64、UInt32、UInt64、Single、Double、Decimal、DateTime、DateTimeOffset、TimeSpan、Guid  
    69.   
  
  
  
  69.         ///   
    70.   
  
  
  
  70.         private object ParseAjaxParameter(string ajaxParameterValue, ParameterInfo parameterInfo)  
    71.   
  
  
  
  71.         {  
    72.   
  
  
  
  72.             object obj;  
    73.   
  
  
  
  73.             if (parameterInfo.ParameterType == typeof(String))  
    74.   
  
  
  
  74.             {  
    75.   
  
  
  
  75.                 obj = ajaxParameterValue;  
    76.   
  
  
  
  76.             }  
    77.   
  
  
  
  77.             else if (parameterInfo.ParameterType == typeof(Boolean))  
    78.   
  
  
  
  78.             {  
    79.   
  
  
  
  79.                 obj = bool.Parse(ajaxParameterValue);  
    80.   
  
  
  
  80.             }  
    81.   
  
  
  
  81.             else if (parameterInfo.ParameterType == typeof(Int32))  
    82.   
  
  
  
  82.             {  
    83.   
  
  
  
  83.                 obj = Int32.Parse(ajaxParameterValue);  
    84.   
  
  
  
  84.             }  
    85.   
  
  
  
  85.             else if (parameterInfo.ParameterType == typeof(UInt32))  
    86.   
  
  
  
  86.             {  
    87.   
  
  
  
  87.                 obj = UInt32.Parse(ajaxParameterValue);  
    88.   
  
  
  
  88.             }  
    89.   
  
  
  
  89.             else if (parameterInfo.ParameterType == typeof(UInt64))  
    90.   
  
  
  
  90.             {  
    91.   
  
  
  
  91.                 obj = UInt64.Parse(ajaxParameterValue);  
    92.   
  
  
  
  92.             }  
    93.   
  
  
  
  93.             else if (parameterInfo.ParameterType == typeof(Single))  
    94.   
  
  
  
  94.             {  
    95.   
  
  
  
  95.                 obj = Single.Parse(ajaxParameterValue);  
    96.   
  
  
  
  96.             }  
    97.   
  
  
  
  97.             else if (parameterInfo.ParameterType == typeof(Double))  
    98.   
  
  
  
  98.             {  
    99.   
  
  
  
  99.                 obj = Double.Parse(ajaxParameterValue);  
    100.   
  
  
  
  100.             }  
    101.   
  
  
  
  101.             else if (parameterInfo.ParameterType == typeof(Decimal))  
    102.   
  
  
  
  102.             {  
    103.   
  
  
  
  103.                 obj = Decimal.Parse(ajaxParameterValue);  
    104.   
  
  
  
  104.             }  
    105.   
  
  
  
  105.             else if (parameterInfo.ParameterType == typeof(DateTime))  
    106.   
  
  
  
  106.             {  
    107.   
  
  
  
  107.                 obj = DateTime.Parse(ajaxParameterValue);  
    108.   
  
  
  
  108.             }  
    109.   
  
  
  
  109.             else if (parameterInfo.ParameterType == typeof(DateTimeOffset))  
    110.   
  
  
  
  110.             {  
    111.   
  
  
  
  111.                 obj = DateTimeOffset.Parse(ajaxParameterValue);  
    112.   
  
  
  
  112.             }  
    113.   
  
  
  
  113.             else if (parameterInfo.ParameterType == typeof(TimeSpan))  
    114.   
  
  
  
  114.             {  
    115.   
  
  
  
  115.                 obj = TimeSpan.Parse(ajaxParameterValue);  
    116.   
  
  
  
  116.             }  
    117.   
  
  
  
  117.             else if (parameterInfo.ParameterType == typeof(Guid))  
    118.   
  
  
  
  118.             {  
    119.   
  
  
  
  119.                 obj = Guid.Parse(ajaxParameterValue);  
    120.   
  
  
  
  120.             }  
    121.   
  
  
  
  121.             else 
    122.   
  
  
  
  122.             {  
    123.   
  
  
  
  123.                 throw new NotSupportedException("方法参数类型不支持！");  
    124.   
  
  
  
  124.             }  
    125.   
  
  
  
  125.             return obj;  
    126.   
  
  
  
  126.         }  
    127.   
  
  
  
  127.    
    128.   
  
  
  
  128.         ///   
    129.   
  
  
  
  129.         /// 结束页面生命周期，同时直接执行应用程序生命周期的EndRequest事件。  
    130.   
  
  
  
  130.         ///   
    131.   
  
  
  
  131.         public void EndRequest()  
    132.   
  
  
  
  132.         {  
    133.   
  
  
  
  133.             HttpResponse response = this.m_AjaxBasePage.Page.Response;  
    134.   
  
  
  
  134.             response.ContentType = "application/json";  
    135.   
  
  
  
  135.             response.Clear();  
    136.   
  
  
  
  136.             JavaScriptSerializer jsonSerializer2 = new JavaScriptSerializer();  
    137.   
  
  
  
  137.             response.Write(jsonSerializer2.Serialize(new JsonResponse { IsSuccess = true, Message = "处理成功", ResponseData = this.m_ResponseData }));  
    138.   
  
  
  
  138.             response.End();  
    139.   
  
  
  
  139.         }  
    140.   
  
  
  
  140.     } 
    141.  
 
 
 
     当初始化了一个AjaxApplication实例后， 可以调用该实例的EndRequest()方法，来结束Ajax请求。该方法内部最后调用Response.End()方法来结束页面生命周期和大部分管线事件。
    并用JsonResponse类来封装返回数据。
     
 
 
 
      
  
  
  
  
    1. public class JsonResponse  
      2.   
  
  
  
    2. {  
      3.   
  
  
  
    3.     public bool IsSuccess { get; set; }  
      4.   
  
  
  
    4.     public string Message { get; set; }  
      5.   
  
  
  
    5.     public object ResponseData { get; set; }  
      6.   
  
  
  
    6. } 
      7.  
 
 
 
    该类最后一个参数即承载了调用方法的返回值，为一个Object类型，也就是说，框架可以支持任何类型的返回值，当然该类型可以被序列化。
    7. 回过头来再看Ajax请求,针对返回值可以这样用：
     
 
 
 
      
  
  
  
  
    1. PowerAjax.AsyncAjax('TestAjaxMethod', [1, 2, "333", "sss"], function (SucceessResponse) {  
      2.   
  
  
  
    2.     if (SucceessResponse.IsSuceess) {  
      3.   
  
  
  
    3.         alert("恭喜，该ajax方法调用成功！");  
      4.   
  
  
  
    4.         Process(SucceessResponse.ResponseData); // 处理返回的数据，这里可能需要你自己实现了，因为我无法判断你要返回的是什么东西，这是个Object  
      5.   
  
  
  
    5.     } else {  
      6.   
  
  
  
    6.         alert("这是操作错误奥，不是内部异常，内部异常的抛出会我内部会处理的！");  
      7.   
  
  
  
    7.         alert("错误信息:" + SucceessResponse.Message);  
      8.   
  
  
  
    8.     }  
      9.   
  
  
  
    9. });  
      10.  
 
 
 
    以上是试水的东西，希望各位大牛指正。
    原文链接：http://www.cnblogs.com/A_ming/archive/2013/03/28/2986949.html
                
    
                当前名称：ASP.NETWebForm也可以这样用Ajax
                
    
                网页URL：http://www.csdahua.cn/qtweb/news41/445241.html
            
    
            
    
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网
            
    
        
        
    
            
    成都快上网为您推荐相关内容
    
            
        
    
    
    
    
        
    
            
    静态网站知识
    
            
        
    
        
    
            
    行业网站建设
    
            
        
    
    
    


    
    
    
        成都app软件开发　　 　成都logo设计公司　　 　普能电气　　 　重庆建站　　 　成都小程序定制开发公司　　 　温江电信机房　　 　店面门头广告　　 　成都网站制作　　 　彭州网站建设　　 　IDC机房托管　　 　成都网络公司　　 　广安搬家公司　　 　乐山服务器托管　　 　成都响应式网站建设　　 　佑馨产后护理　　 　眉山托管服务器　　 　简阳威斯达宇　　 　整合营销　　 　研帮主　　 　成都二枢机房