ASP.NET ScriptManager control has a property
LoadScriptsBeforeUI, when set to false, should
load all AJAX framework scripts after the content of the page. But
it does not effectively push down all scripts
after the content. Some framework scripts, extender scripts and
other scripts registered by Ajax Control Toolkit still load before
the page content loads. The following screen taken from www.dropthings.com shows several
script tags are still added at the beginning of
In ASP.NET 2.0, you to create Response Filter which is an
implementation of a Stream. You can replace default
Response.Filter with your own stream and then ASP.NET will
use your filter to write the final rendered HTML. When
Response.Write is called or Page’s Render method
fires, the response is written to the output stream via the filter.
So, you can intercept every byte that’s going to be sent to the
client (browser) and modify it the way you like. Response Filters
can be used in variety ways to optimize Page output like stripping
off all white spaces or doing some formatting on the generated
content, or manipulating the characters being sent to the browser
and so on.
I have created a Response filter which captures all characters
being sent to the browser. It it finds that script blocks are being
rendered, instead of rendering it to the
Response.OutputStream, it will extract the script blocks out
of the buffer being written and render the rest of the content. It
stores all script blocks, both internal and external, in a string
buffer. When it detects tag is about to be
written to the response, it flushes all the captured script blocks
from the string buffer.
1: public class ScriptDeferFilter : Stream
2: {
3: Stream responseStream;
4: long position;
5:
6: ///
7: /// When this is true, script blocks are suppressed and captured for
8: /// later rendering
9: ///
10: bool captureScripts;
11:
12: ///
13: /// Holds all script blocks that are injected by the controls
14: /// The script blocks will be moved after the form tag renders
15: ///
16: StringBuilder scriptBlocks;
17:
18: Encoding encoding;
19:
20: public ScriptDeferFilter(Stream inputStream, HttpResponse response)
21: {
22: this.encoding = response.Output.Encoding;
23: this.responseStream = response.Filter;
24:
25: this.scriptBlocks = new StringBuilder(5000);
26: // When this is on, script blocks are captured and not written to output
27: this.captureScripts = true;
28: }
Here’s the beginning of the Filter class. When it initializes,
it takes the original Response Filter. Then it overrides the
Write method of the Stream so that it can capture the
buffers being written and do it’s own processing.
1: public override void Write(byte[] buffer, int offset, int count)
2: {
3: // If we are not capturing script blocks anymore, just redirect to response stream
4: if (!this.captureScripts)
5: {
6: this.responseStream.Write(buffer, offset, count);
7: return;
8: }
9:
10: /*
11: * Script and HTML can be in one of the following combinations in the specified buffer:
12: * .....< script ....>..........
13: * < script ....>..........
14: * < script ....>.....
15: * < script ....>..... .....
16: * ....< script ....>.....
17: * < script ....>.....
18: * ..........
19: * .....
20: * < script>.....
21: * ....
22: * ......
23: * Here, "...." means html content between and outside script tags
24: */
25:
26: char[] content = this.encoding.GetChars(buffer, offset, count);
27:
28: int scriptTagStart = 0;
29: int lastScriptTagEnd = 0;
30: bool scriptTagStarted = false;
31:
32: for (int pos = 0; pos < content.Length; pos++)
33: {
34: // See if tag start
35: char c = content[pos];
36: if (c == '<')
37: {
38: int tagStart = pos;
39: // Check if it's a tag ending
40: if (content[pos+1] == '/')
41: {
42: pos+=2; // go past the
43:
44: // See if script tag is ending
45: if (isScriptTag(content, pos))
46: {
47: /// Script tag just ended. Get the whole script
48: /// and store in buffer
49: pos = pos + "script>".Length;
50: scriptBlocks.Append(content, scriptTagStart, pos - scriptTagStart);
51: scriptBlocks.Append(Environment.NewLine);
52: lastScriptTagEnd = pos;
53:
54: scriptTagStarted = false;
55: continue;
56: }
57: else if (isBodyTag(content, pos))
58: {
59: /// body tag has just end. Time for rendering all the script
60: /// blocks we have suppressed so far and stop capturing script blocks
61:
62: if (this.scriptBlocks.Length > 0)
63: {
64: // Render all pending html output till now
65: this.WriteOutput(content, lastScriptTagEnd, tagStart - lastScriptTagEnd);
66:
67: // Render the script blocks
68: byte[] scriptBytes = this.encoding.GetBytes(this.scriptBlocks.ToString());
69: this.responseStream.Write(scriptBytes, 0, scriptBytes.Length);
70:
71: // Stop capturing for script blocks
72: this.captureScripts = false;
73:
74: // Write from the body tag start to the end of the inut buffer and return
75: // from the function. We are done.
76: this.WriteOutput(content, tagStart, content.Length - tagStart);
77: return;
78: }
79: }
80: else
81: {
82: // some other tag's closing. safely skip one character as smallest
83: // html tag is one character e.g. . just an optimization to save one loop
84: pos++;
85: }
86: }
87: else
88: {
89: if (isScriptTag(content, pos+1))
90: {
91: /// Script tag started. Record the position as we will
92: /// capture the whole script tag including its content
93: /// and store in an internal buffer.
94: scriptTagStart = pos;
95:
96: // Write html content since last script tag closing upto this script tag
97: this.WriteOutput(content, lastScriptTagEnd, scriptTagStart - lastScriptTagEnd);
98:
99: // Skip the tag start to save some loops
100: pos += "< script".Length;
101:
102: scriptTagStarted = true;
103: }
104: else
105: {
106: // some other tag started
107: // safely skip 2 character because the smallest tag is one character e.g.
108: // just an optimization to eliminate one loop
109: pos++;
110: }
111: }
112: }
113: }
114:
115: // If a script tag is partially sent to buffer, then the remaining content
116: // is part of the last script block
117: if (scriptTagStarted)
118: {
119:
120: this.scriptBlocks.Append(content, scriptTagStart, content.Length - scriptTagStart);
121: }
122: else
123: {
124: /// Render the characters since the last script tag ending
125: this.WriteOutput(content, lastScriptTagEnd, content.Length - lastScriptTagEnd);
126: }
127: }
There are several situations to consider here. The Write
method is called several times during the Page render process
because the generated HTML can be quite big. So, it will contain
partial HTML. So, it's possible the first Write call contains a
start of a script block, but no ending script tag. The following
Write call may or may not have the ending script block. So, we need
to preserve state to make sure we don't overlook any script block.
Each Write call can have several script block in the buffer
as well. It can also have no script block and only page
content.
The idea here is to go through each character and see if there's
any starting script tag. If there is, remember the start position
of the script tag. If script end tag is found within the buffer,
then extract out the whole script block from the buffer and render
the remaining html. If there's no ending tag found but a script tag
did start within the buffer, then suppress output and capture the
remaining content within the script buffer so that next call to
Write method can grab the remaining script and extract it
out from the output.
There are two other private functions that are basically helper
functions and does not do anything interesting:
1: private void WriteOutput(char[] content, int pos, int length)
2: {
3: if (length == 0) return;
4:
5: byte[] buffer = this.encoding.GetBytes(content, pos, length);
6: this.responseStream.Write(buffer, 0, buffer.Length);
7: }
8:
9: private bool isScriptTag(char[] content, int pos)
10: {
11: if (pos + 5 < content.Length)
12: return ((content[pos] == 's' || content[pos] == 'S')
13: && (content[pos + 1] == 'c' || content[pos + 1] == 'C')
14: && (content[pos + 2] == 'r' || content[pos + 2] == 'R')
15: && (content[pos + 3] == 'i' || content[pos + 3] == 'I')
16: && (content[pos + 4] == 'p' || content[pos + 4] == 'P')
17: && (content[pos + 5] == 't' || content[pos + 5] == 'T'));
18: else
19: return false;
20:
21: }
22:
23: private bool isBodyTag(char[] content, int pos)
24: {
25: if (pos + 3 < content.Length)
26: return ((content[pos] == 'b' || content[pos] == 'B')
27: && (content[pos + 1] == 'o' || content[pos + 1] == 'O')
28: && (content[pos + 2] == 'd' || content[pos + 2] == 'D')
29: && (content[pos + 3] == 'y' || content[pos + 3] == 'Y'));
30: else
31: return false;
32: }
The isScriptTag and isBodyTag functions may look
weird. The reason for such weird code is pure performance. Instead
of doing fancy checks like taking a part of the array out and doing
string comparison, this is the fastest way of doing the check. Best
thing about .NET IL is that it's optimized, if any of the condition
in the && pairs fail, it won't even execute the rest. So,
this is as best as it can get to check for certain
characters.
There are some corner cases that are not handled here. For
example, what if the buffer contains a partial script tag
declaration. For example, "....
remaining characters did not finish in the buffer instead next
buffer is sent with the remaining characters like "ipt src="..."
>...... In such case, the script tag won't be
taken out. One way to handle this would be to make sure you always
have enough characters left in the buffer to do a complete tag name
check. If not found, store the half finished buffer somewhere and
on next call to Write, combine it with the new buffer sent and do
the processing.
In order to install the Filter, you need to hook it in in the
Global.asax BeginRequest or some other event that's fired before
the Response is generated.
1: protected void Application_BeginRequest(object sender, EventArgs e)
2: {
3: if (Request.HttpMethod == "GET")
4: {
5: if (Request.AppRelativeCurrentExecutionFilePath.EndsWith(".aspx"))
6: {
7: Response.Filter = new ScriptDeferFilter(Response);
8: }
9: }
10: }
Here I am hooking the Filter only for GET calls to
.aspx pages. You can hook it to POST calls as well. But
asynchronous postbacks are regular POST and I do not want to
do any change in the generated JSON or html fragment. Another way
is to hook the filter only when ContentType is
text/html.
When this filter is installed, www.dropthings.com defers all
script loading after the