|
当你添加Asp.net AJAX功能到你的Web程序的时候，你需要在Web.config中做一些改变，需要你显式地移除默认的ASMX处理程序并且添加asp.net
ajax框架自己的脚本处理器来作为ASMX处理程序。在上一篇异步调用Web服务方法中，我们谈论过，ajax框架的asmx(ScriptHandler)是不支持异步调用Web服务方法的，所以为了让asp.netajax支持异步Web方法调用，我们需要避开该处理器，以提供自定义的处理器来取代它。
Asp.netAJAX框架的ASMX处理器——ScriptHandler
ScriptHandler是一个常规的HTTP处理程序，它能够通过解析URL找出调用了哪个Web服务及Web方法。然后对应于Web服务类型通过反射来执行Web方法。调用Web方法所涉及的步骤如下：
1、 通过检查Content-Type来确认这是一个基于Ajax的Web方法调用，并查看它是否有application/json的属性。如果没有，则激活一个异常。
2、 通过解析请求的URL找出哪个.asmx被调用，返回.asmx文件类型且被编译过的程序集。
3、 反射程序集并找出Web服务和被调用的Web方法
4、 反序列化输入参数到适当的数据类型中，以防Http POST反序列化JSON图表
5、 查看方法中的参数并映射每个参数到JSON反序列化的对象上
6、 初始化缓存策略
7、 通过反射调用方法并且传递与JSON匹配的参数值
8、 获取返回值。序列化返回值到JSON/XML
9、 发射JSON/XML作为响应
基本的异步Web服务处理程序
首先你需要一个Http处理程序，它将拦截所有对Web服务的调用。在Web.config的<httphandlers>节点下你需要映射该处理程序到*.asmx来进行扩展。默认情况下，asp.net
ajax将映射到ScriptHandler来处理*.asmx扩展名类型的文件，因此需要用你自己的Http处理程序来取代它。
在提供的代码中，ASMXHttpHandler.cs是主要的HTTP处理程序类。ASMXHttpHandler类实现了IhttpAsyncHandler接口。调用Web服务期间，当该处理程序被调用的时候，asp.net框架会首先调用BeginProcessRequest方法。在该方法中，处理程序会解析锁请求的URL并找出调用了哪个Web服务的Web方法。
IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
// Proper Content-Type header must be present in order to make a REST call
if (!IsRestMethodCall(context.Request))
{
return GenerateErrorResponse(context, "Not a valid REST call", extraData);
}
string methodName = context.Request.PathInfo.Substring(1);
WebServiceDef wsDef = WebServiceHelper.GetWebServiceType(context, context.Request.FilePath);
WebMethodDef methodDef = wsDef.Methods[methodName];
if (null == methodDef) return GenerateErrorResponse(context, "Web method not supported: " + methodName, extraData);
// GET request will only be allowed if the method says so
if (context.Request.HttpMethod == "GET" && !methodDef.IsGetAllowed)
return GenerateErrorResponse(context, "Http Get method not supported", extraData);
context.Response.Filter = new ResponseFilter(context.Response);
// If the method does not have a BeginXXX and EndXXX pair, execute it synchronously
if (!methodDef.HasAsyncMethods)
{ |
WebServiceDef类对Type类进行了包装，同时还包含Web服务类型的一些信息。它维护了WebMethodDef类的集合项，其中每项都包含对某个Web方法的定义。WebMethodDef类为每个方法，与方法相关的特性、是否支持Http
GET方式以及如果可能，对Begin和End方法对的引用都提供了一个名称。如果没有Begin和End方法对，该方法会如下例代码所示，以同步方式执行。所有的这些类都作为Web服务和Web方法进行缓存处理，因此不需要重复使用反射查看元数据。
// If the method does not have a BeginXXX and EndXXX pair, execute it synchronously
if (!methodDef.HasAsyncMethods)
{
// Do synchronous call
ExecuteMethod(context, methodDef, wsDef);
// Return a result that says method was executed synchronously
return new AsmxHandlerSyncResult(extraData);
} |
当方法同步执行的时候，BeginProcessRequest将立即返回。它将返回一个AsmxHandlerSyncRequest实例，表示请求以按同步方式执行并且不需要出发EndProcessRequest方法。AsmxHandlerSyncRequest类实现了IasyncRequest接口。它会从CompletedSynchronously属性返回真值。
public class AsmxHandlerSyncResult : IAsyncResult
{
#region Fields
private WaitHandle handle = new ManualResetEvent(true);
private object state;
#endregion Fields
#region Constructors
public AsmxHandlerSyncResult(object state)
{
this.state = state;
}
#endregion Constructors
#region Properties
object IAsyncResult.AsyncState
{
get { return this.state; }
}
WaitHandle IAsyncResult.AsyncWaitHandle
{
get { return this.handle; }
}
bool IAsyncResult.CompletedSynchronously
{
get { return true; }
}
bool IAsyncResult.IsCompleted
{
get { return true; }
}
#endregion Properties
} |
回到BeginProcessRequest方法上，当存在Begin和End方法对的时候，它会调用Web方法的BeginXXX方法并从该方法返回。执行到Asp.net框架并返回线程到线程池。
下面的代码展示了调用Web服务上BeginXXX方法的准备步骤。首先，除了最后两个参数(一个是AsyncCallback，另一个是某个对象状态)，来自请求的所有参数都需要进行适当的映射。
else
{
// Call the Begin method of web service
IDisposable target = Activator.CreateInstance(wsDef.WSType) as IDisposable;
WebMethodDef beginMethod = methodDef.BeginMethod;
int allParameterCount = beginMethod.InputParametersWithAsyc.Count;
IDictionary <string, object> inputValues = GetRawParams(context, beginMethod.InputParameters, wsDef.Serializer);
object[] parameterValues = StrongTypeParameters(inputValues, beginMethod.InputParameters);
// Prepare the list of parameter values which will also include the AsyncCallback and the state
object[] parameterValuesWithAsync = new object[allParameterCount];
Array.Copy(parameterValues, parameterValuesWithAsync, parameterValues.Length);
// Populate last two parameters with async callback and state
parameterValuesWithAsync[allParameterCount - 2] = cb;
AsyncWebMethodState webMethodState = new AsyncWebMethodState(methodName, target,
wsDef, methodDef, context, extraData);
parameterValuesWithAsync[allParameterCount - 1] = webMethodState; |
注：Web服务从System.Web.Services.WebService命名空间继承，并实现了Idisposable接口。Activator.CreateInstance是.net框架类的一个实例，它能从自己的类型中动态实例化任何类并返回一个对象的引用。在上例代码中，Web服务类实例被创建，并且使用了对Idisposable接口的引用。使用Idisposable接口是因为当我们调用结束后需要释放占用的资源。
一旦准备工作完成，BeginXXX方法会被调用。现在BeginXXX方法能同步执行并立即返回。在这种情况下，你必须完整地产生BeginXXX方法的响应并完成该请求的执行。但是，如果BeginXXX方法需要更多的时间来异步执行的话，你需要为Asp.net框架返回该执行以便它把线程返回给线程池。当异步操作完成后，EndProcessRequest方法将执行回调并继续处理该请求。
try
{
// Invoke the BeginXXX method and ensure the return result has AsyncWebMethodState. This state
// contains context and other information which we need in oreder to call the EndXXX
IAsyncResult result = beginMethod.MethodType.Invoke(target, parameterValuesWithAsync) as IAsyncResult;
// If execution has completed synchronously within the BeginXXX function, then generate response
// immediately. There's no need to call EndXXX
if (result.CompletedSynchronously)
{
object returnValue = result.AsyncState;
GenerateResponse(returnValue, context, methodDef, wsDef);
target.Dispose();
return new AsmxHandlerSyncResult(extraData);
}
else
{
if (result.AsyncState is AsyncWebMethodState) return result;
else throw new InvalidAsynchronousStateException("The state passed in the " + beginMethod.MethodName +
" must inherit from " + typeof(AsyncWebMethodState).FullName);
}
}
catch (Exception x)
{
target.Dispose();
WebServiceHelper.WriteExceptionJsonString(context, x, wsDef.Serializer);
return new AsmxHandlerSyncResult(extraData);
} |
当异步操作完成并且回调被激活的时候，EndProcessRequest方法也被激活。例如，如果你异步调用某个外部Web服务其里面包含了命名为BeginXXX的Web方法，则你需要传递一个对AsyncCallback的引用。这会为你接受到的BeginProcessRequest执行同样的回调。Asp.net框架会给你创建一个回调的引用，你可以在HTTP处理程序中用Web服务的EndXXX方法来获得响应和产生输出。
void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result)
{
if (result.CompletedSynchronously) return;
AsyncWebMethodState state = result.AsyncState as AsyncWebMethodState;
if (result.IsCompleted)
{
MethodInfo endMethod = state.MethodDef.EndMethod.MethodType;
try
{
object returnValue = endMethod.Invoke(state.Target, new object[] { result });
GenerateResponse(returnValue, state.Context, state.MethodDef, state.ServiceDef);
}
catch (Exception x)
{
WebServiceHelper.WriteExceptionJsonString(state.Context, x, state.ServiceDef.Serializer);
}
finally
{
state.Target.Dispose();
}
state.Dispose();
}
} |
当EndXXX类的Web方法调用完成后，如果该方法不是一个返回空类型的方法，你将得到一个返回值，在这种情况下，你需要把该返回值转换到某个JSON格式的字符串中并返回到浏览器端。然而，该方法也可以返回某个XML格式的字符串而取代JSON格式。因此，仅需要把这些字符串写入到HttpResponse对象即可。
private void GenerateResponse(object returnValue, HttpContext context, WebMethodDef methodDef, WebServiceDef serviceDef)
{
if (context.Response.Filter.Length > 0)
{
// Response has already been transmitted by the WebMethod.
// So, do nothing
return;
}
string responseString = null;
string contentType = "application/json";
if (methodDef.ResponseFormat == System.Web.Script.Services.ResponseFormat.Json)
{
responseString = "{ d : (" + serviceDef.Serializer.Serialize(returnValue) + ")}";
contentType = "application/json";
}
else if (methodDef.ResponseFormat == System.Web.Script.Services.ResponseFormat.Xml)
{
responseString = returnValue as string;
contentType = "text/xml";
}
context.Response.ContentType = contentType;
// If we have response and no redirection happening and client still connected, send response
if (responseString != null
&& !context.Response.IsRequestBeingRedirected
&& context.Response.IsClientConnected)
{<pre class="csharp" name="code">// Convert the response to response encoding, e.g. utf8
byte[] unicodeBytes = Encoding.Unicode.GetBytes(responseString);
byte[] utf8Bytes = Encoding.Convert(Encoding.Unicode, context.Response.ContentEncoding, unicodeBytes);
// Emit content length in UTF8 encoding string
context.Response.AppendHeader("Content-Length", utf8Bytes.Length.ToString());
// Instead of Response.Write which will convert the output to UTF8, use the internal stream
// to directly write the utf8 bytes
context.Response.OutputStream.Write(utf8Bytes, 0, utf8Bytes.Length);
}
else
{
// Send no body as response and we will just abort it
context.Response.AppendHeader("Content-Length", "0");
context.Response.ClearContent();
context.Response.StatusCode = 204; // No Content
}
}</pre><br>
<pre></pre>
<br>
<p><strong>为Web方法添加事务化的能力</strong></p>
<p>到此为止，Web方法的执行并没有支持事务。可以使用[TransactionalMethod]特性来界定事务包括的范围、代码的隔离
级别和超时时段。</p>
<p></p>
<p>带有TransactionalMethod特性的Web方法将在事务块中自动执行。这里我们将使用.net 2.0事务。事务管理完全在HTTP
处理程序中执行并且Web方法并不需要做过多事情。当Web方法遇到异常的时候，事务会自动回滚；否则，事务将自动提交。
</p>
<p>ASMXHttpHandler的ExecuteMethod方法同步调用Web方法并提供了事务支持。目前，由于从一个线程到另一个线程的
不断转换，针对异步方法的事务支持还没有实现。所以TransactionScope从本地线程存储中的特性丢失了。</p>
<pre class="csharp" name="code">private void ExecuteMethod(HttpContext context, WebMethodDef methodDef,
WebServiceDef serviceDef)
{
IDictionary<string, object> inputValues = GetRawParams(context, methodDef.InputParameters,
serviceDef.Serializer);
object[] parameters = StrongTypeParameters(inputValues, methodDef.InputParameters);
object returnValue = null;
using (IDisposable target = Activator.CreateInstance(serviceDef.WSType) as IDisposable)
{
TransactionScope ts = null;
try
{
// If the method has a transaction attribute, then call the method within a transaction scope
if (methodDef.TransactionAtt != null)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = methodDef.TransactionAtt.IsolationLevel;
options.Timeout = TimeSpan.FromSeconds( methodDef.TransactionAtt.Timeout );
ts = new TransactionScope(methodDef.TransactionAtt.TransactionOption, options);
}
returnValue = methodDef.MethodType.Invoke(target, parameters);
// If transaction was used, then complete the transaction because no exception was
// generated
if( null != ts ) ts.Complete();
GenerateResponse(returnValue, context, methodDef, serviceDef);
}
catch (Exception x)
{
WebServiceHelper.WriteExceptionJsonString(context, x, serviceDef.Serializer);
}
finally
{
// If transaction was started for the method, dispose the transaction. This will
// rollback if not committed
if( null != ts) ts.Dispose();
// Dispose the web service
target.Dispose();
}
}
}</pre><br>
<p>上例代码展示了一个执行得当的Web方法并产生一个响应。该Web方法在一个定义为TransactionalMethod特性的事务
范围块内执行。但是当Web方法抛出一个异常的时候，它会定位到出现异常消息块的地方。最终，TransactionScope
被释放并会检查本次操作是否已经提交。如果没有提交，TransactionScope会回滚该事务。</p>
<pre class="csharp" name="code">catch (Exception x)
{
WebServiceHelper.WriteExceptionJsonString(context, x, serviceDef.Serializer);
}
finally
{
// If transaction was started for the method, dispose the transaction. This will
// rollback if not committed
if( null != ts) ts.Dispose();
// Dispose the web service
target.Dispose();
}</pre><br>
<p>整个事务化管理都位于HTTP处理程序中，因此，不需要担心Web服务中的事务。仅需要添加一个特性，然后该Web方法
就具有了事务特性。</p>
<p><strong>添加缓存头</strong></p>
<p>Asp.net Ajax框架在调用Web方法之前会进行缓存策略初始化操作。如果你没有在[WebMethod]属性中设置缓存持续
时间，那么它将把MaxAge设置为零。一旦MaxAge被设置为零，就不能再对它增加。因此，为了从浏览器端获取缓存响应，
你不能动态地从你的Web方法代码中增加MaxAge的值。而由于HttpCachePolicy的限制，一旦设定MaxAge的值，就不能再
对它进行增加。此外，如果你使用Http检测工具来查看从Web服务调用返回的响应，你将会看到该响应丢失了
Content-Length特性。没有该特性，浏览器不能使用Http管道，这将很大滴提升Http响应的下载时间。</p>
<p> </p>
<p>为了处理缓存策略，在GenerateResponse方法中作了一些补充。我们的想法是该Web方法在HttpResponse对象中
已经设置了一些缓存策略，因此它将不会改变任何缓存设置。否则，它会进行缓存设置检查是否应用了WebMethod特性，
然后设置缓存头。</p>
<pre class="csharp" name="code">
// If we have response and no redirection happening and client still connected, send response
if (responseString != null
&& !context.Response.IsRequestBeingRedirected
&& context.Response.IsClientConnected)
{
// Produce proper cache. If no cache information specified on method and there's been no cache related
// changes done within the web method code, then default cache will be private, no cache.
if (IsCacheSet(context.Response) || methodDef.IsETagEnabled)
{
// Cache has been modified within the code. So, do not change any cache policy
}
else
{
// Cache is still private. Check if there's any CacheDuration set in WebMethod
int cacheDuration = methodDef.WebMethodAtt.CacheDuration;
if (cacheDuration > 0)
{
// If CacheDuration attribute is set, use server side caching
context.Response.Cache.SetCacheability(HttpCacheability.Server);
context.Response.Cache.SetExpires(DateTime.Now.AddSeconds(cacheDuration));
context.Response.Cache.SetSlidingExpiration(false);
context.Response.Cache.SetValidUntilExpires(true);
if (methodDef.InputParameters.Count > 0)
{
context.Response.Cache.VaryByParams["*"] = true;
}
else
{
context.Response.Cache.VaryByParams.IgnoreParams = true;
}
}
else
{
context.Response.Cache.SetNoServerCaching();
context.Response.Cache.SetMaxAge(TimeSpan.Zero);
}
}
// Check if there's any need to do ETag match. If ETag matches, produce HTTP 304, otherwise
// render the content along with the ETag
if (methodDef.IsETagEnabled)
{
string etag = context.Request.Headers["If-None-Match"];
string hash = GetMd5Hash(responseString);
if (!string.IsNullOrEmpty(etag))
{
if (string.Compare(hash, etag, true) == 0)
{
// Send no body as response and we will just abort it
context.Response.ClearContent();
context.Response.AppendHeader("Content-Length", "0");
context.Response.SuppressContent = true;
context.Response.StatusCode = 304;
// No need to produce output response body
return;
}
}
// ETag comparison did not happen or comparison did not match. So, we need to produce new ETag
HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.Public);
HttpContext.Current.Response.Cache.AppendCacheExtension("must-revalidate, proxy-revalidate");
HttpContext.Current.Response.Cache.SetETag(hash);
HttpContext.Current.Response.Cache.SetLastModified(DateTime.Now);
int cacheDuration = methodDef.WebMethodAtt.CacheDuration;
if (cacheDuration > 0)
{
context.Response.Cache.SetExpires(DateTime.Now.AddMinutes(cacheDuration));
context.Response.Cache.SetMaxAge(TimeSpan.FromMinutes(cacheDuration));
}
else
{
context.Response.Cache.SetMaxAge(TimeSpan.FromSeconds(10));
}
}
// Convert the response to response encoding, e.g. utf8
byte[] unicodeBytes = Encoding.Unicode.GetBytes(responseString);
byte[] utf8Bytes = Encoding.Convert(Encoding.Unicode, context.Response.ContentEncoding, unicodeBytes);
// Emit content length in UTF8 encoding string
context.Response.AppendHeader("Content-Length", utf8Bytes.Length.ToString());
// Instead of Response.Write which will convert the output to UTF8, use the internal stream
// to directly write the utf8 bytes
context.Response.OutputStream.Write(utf8Bytes, 0, utf8Bytes.Length);
}</pre><br>
<br>
<p>IsCacheSet方法检查在一些通用的缓存设置中是否有任何变化。如果发生变化，Web方法本身需要对缓存进行处理
（由框架完成），并且GenerateResponse方法对于缓存策略并没有发生任何改变。</p>
<p><pre class="csharp" name="code"> private bool IsCacheSet(HttpResponse response)
{
if (response.CacheControl == "public") return true;
FieldInfo maxAgeField = response.Cache.GetType().GetField("_maxAge", BindingFlags.GetField |
BindingFlags.Instance | BindingFlags.NonPublic);
TimeSpan maxAgeValue = (TimeSpan)maxAgeField.GetValue(response.Cache);
if (maxAgeValue != TimeSpan.Zero) return true;
return false;
}</pre><br>
<strong>使用</strong><p></p>
<p>只需在Web.config中将ScriptHandler处理器用该处理器替代即可。</p>
<p><br>
</p>
<p><span style="font-size: 18px;"><a href="http://download.csdn.net/detail/yanghua_kobe/3878998">源代码下载
</a></span></p> |
|
