窥探：属性HttpResponse.Filter和方法 HttpResponse.SwitchWriter

　　wap站由于浏览器的原因，只能依赖url来做用户标识了，如此我们就必须对输出页面中的url做处理了。就是说要截住response的内容，然后对其进行处理。

　　

　　首先来看段源码：

internal TextWriter SwitchWriter(TextWriter writer)
{
TextWriter writer2 = this._writer;
this._writer = writer;
return writer2;
}　　原来的代码里用此方法来替换HttpResponse的输出对象。留意了，是替换，把原有的替换了。接下来看看原有的writer是什么东东。

　　

　　

internal void InitResponseWriter()
{
if (this._httpWriter == null)
{
this._httpWriter = new HttpWriter(this);
this._writer = this._httpWriter;
}
}默认情况writer的东东都写到httpwriter里面去了。

HttpResponse.Writer:

public void Write(char ch)
{
this._writer.Write(ch);
}注：SwitchWriter的方法返回的是老的response._writer的对象，如果咱们在输出前通过SwithchiWriter获取默认的_htppWriter对象来进行处理的话，我们得到的只能是空串，原因是httpWriter对象默认直接将流输出到客户端了。

所以原来的代码调用了2次SwitchWriter，在OnActionExecuting中把默认的_htppWriter用HtmlTextWriter的实例替换掉，待action执行完成，再在OnResultExecuted中再一次调用SwitchWriter将先前替换进去的对象取出来。（不明白，再看看SwitchWriter的定义）。

SwitchWriter方法是internal的，我们只能靠反射干它了。

哈哈，其实现在的实现也挺好。问题出现在有bug的时候，什么叫有bug的时候就有问题，岂不是废话，有bug当然有问题了，呵，别着急，慢慢来。

在MVC中，如果咱们自己写的Action代码出现了异常，其是不会走OnResultExecuted事件的，直接跳转到OnException 里去处理了，也就是要想把Resopnse 对应的输出去出来，让程序员看到“黄页”那还得在OnException里去进行一次SwitchWriter来取错误信息。也罢也罢。关键也不知道写着代码的人知道其中逻辑，目前OnException只做了跳转，“黄页”永远都告别了程序员和用户。“黄页”对debug来说有多重要就不说了。

　　因为这个问题，我们不得不想起HttpResponse.Filter。

public Stream Filter
{
get
{
if (this.UsingHttpWriter)
{
return this._httpWriter.GetCurrentFilter();
}
return null;
}
set
{
if (!this.UsingHttpWriter)
{
throw new HttpException(SR.GetString("Filtering_not_allowed"));
}
this._httpWriter.InstallFilter(value);
IIS7WorkerRequest request = this._wr as IIS7WorkerRequest;
if (request != null)
{
request.ResponseFilterInstalled();
}
}
}看到这里应该知道为啥人家把SwitchWriter方法给internal起来了。

internal void InstallFilter(Stream filter)
{
if (this._filterSink == null)
{
throw new HttpException(SR.GetString("Invalid_response_filter"));
}
this._installedFilter = filter;
}

算看出来了，filter的功能是HttpWriter 提供的filter方法实现的：

internal void Filter(bool finalFiltering)
{
if (this._installedFilter != null)
{
if (this._charBufferLength != this._charBufferFree)
{
this.FlushCharBuffer(true);
}
this._lastBuffer = null;
if (this._buffers.Count != 0)
{
ArrayList list = this._buffers;
this._buffers = new ArrayList();
this._filterSink.Filtering = true;
try
{
int count = list.Count;
for (int i = 0; i < count; i++)
{
IHttpResponseElement element = (IHttpResponseElement) list[i];
long size = element.GetSize();
if (size > 0L)
{
this._installedFilter.Write(element.GetBytes(), 0, Convert.ToInt32(size));
}
}
this._installedFilter.Flush();
}
finally
{
try
{
if (finalFiltering)
{
this._installedFilter.Close();
}
}
finally
{
this._filterSink.Filtering = false;
}
}
}
}
}　　filter在输出前做过滤筛选，方便。

　　有一个不太好的地方是，MS公布出来个Stream类型的filter，很不让人好理解。强烈要求放出个delegate，意思明了多了。

想起来了，之前在action里面用 Response.End();返回的却是空的页面。

那就再偷窥下end方法。我们在actionexcuting中用SwithWrite方法把 默认的httpwriter换成了TextWriter的实例，我们来看看End方法。

public void End()
{
if (this._context.IsInCancellablePeriod)
{
InternalSecurityPermissions.ControlThread.Assert();
Thread.CurrentThread.Abort(new HttpApplication.CancelModuleException(false));
}
else if (!this._flushing)
{
this.Flush();
this._ended = true;
if (this._context.ApplicationInstance != null)
{
this._context.ApplicationInstance.CompleteRequest();
}
}
}我们发现，我们得跟Flush()方法。

public void Flush()
{
if (this._completed)
{
throw new HttpException(SR.GetString("Cannot_flush_completed_response"));
}
this.Flush(false);
}

private void Flush(bool finalFlush)
{
if (!this._completed && !this._flushing)
{
if (this._httpWriter == null)
{
this._writer.Flush();
}
else
{
this._flushing = true;
try
{
IIS7WorkerRequest request = this._wr as IIS7WorkerRequest;
if (request != null)
{
this.GenerateResponseHeadersForHandler();
this.UpdateNativeResponse(true);
request.ExplicitFlush();
this._headersWritten = true;
}
else
{
long contentLength = 0L;
if (!this._headersWritten)
{
if (!this._suppressHeaders && !this._clientDisconnected)
{
if (finalFlush)
{
contentLength = this._httpWriter.GetBufferedLength();
if ((!this._contentLengthSet && (contentLength == 0L)) && (this._httpWriter != null))
{
this._contentType = null;
}
if (((this._cachePolicy != null) && (this._cookies != null)) && (this._cookies.Count != 0))
{
this._cachePolicy.SetHasSetCookieHeader();
this.DisableKernelCache();
}
this.WriteHeaders();
contentLength = this._httpWriter.GetBufferedLength();
if (!this._contentLengthSet && (this._statusCode != 0x130))
{
this._wr.SendCalculatedContentLength(contentLength);
}
}
else
{
if ((!this._contentLengthSet && !this._transferEncodingSet) && (this._statusCode == 200))
{
string httpVersion = this._wr.GetHttpVersion();
if ((httpVersion != null) && httpVersion.Equals("HTTP/1.1"))
{
this.AppendHeader(new HttpResponseHeader(6, "chunked"));
this._chunked = true;
}
contentLength = this._httpWriter.GetBufferedLength();
}
this.WriteHeaders();
}
}
this._headersWritten = true;
}
else
{
contentLength = this._httpWriter.GetBufferedLength();
}
if (!this._filteringCompleted)
{
this._httpWriter.Filter(false);
contentLength = this._httpWriter.GetBufferedLength();
}
if ((!this._suppressContentSet && (this.Request != null)) && (this.Request.HttpVerb == HttpVerb.HEAD))
{
this._suppressContent = true;
}
if (this._suppressContent || this._ended)
{
this._httpWriter.ClearBuffers();
contentLength = 0L;
}
if (!this._clientDisconnected)
{
if ((this._context != null) && (this._context.ApplicationInstance != null))
{
this._context.ApplicationInstance.RaiseOnPreSendRequestContent();
}
if (this._chunked)
{
if (contentLength > 0L)
{
byte[] bytes = Encoding.ASCII.GetBytes(Convert.ToString(contentLength, 0x10) + "\r\n");
this._wr.SendResponseFromMemory(bytes, bytes.Length);
this._httpWriter.Send(this._wr);
this._wr.SendResponseFromMemory(s_chunkSuffix, s_chunkSuffix.Length);
}
if (finalFlush)
{
this._wr.SendResponseFromMemory(s_chunkEnd, s_chunkEnd.Length);
}
}
else
{
this._httpWriter.Send(this._wr);
}
this._wr.FlushResponse(finalFlush);
this._wr.UpdateResponseCounters(finalFlush, (int) contentLength);
if (!finalFlush)
{
this._httpWriter.ClearBuffers();
}
}
}
}
finally
{
this._flushing = false;
if (finalFlush)
{
this._completed = true;
}
}
}
}
}

这才发现，这个end 依赖于_writer的法律flush方法，而TextWrter的实现是：

[MethodImpl(MethodImplOptions.Synchronized)]
public override void Flush()
{
this._out.Flush();
}

所以，默认情况下end方法依赖于默认的httpwriter的flush实现，或者自己重写textwriter的flush方法。