How can you verify this is actually working as you expect? You can an HTTP monitoring tool to see the requests your browser send and the responses the web server sends back. My favorite tool for this is Fiddler. 

Here’s a screen capture  of fiddler (click the link to see a larger image):

Notice that the first request we get is a regular HTTP 200 response with the actual data (5 bytes in our case as seen in the body column). The second and third requests return a 304 response as expected.

If you look at the request headers you’ll see the expected If-Modified-Since (upper right pane) :

 
The Fiddler Timeline add-in provides a graphical layout of the requests, their timing, cache status and connection status. If you’ll go back to the first image you’ll notice that the second and third requests have a floppy icon near them which means these requests were served from the local cache instead of the server. You might also notice a red circle near that floppy.. That’s what this post is all about.

The red circle means the connection will be ended by the server after the response is over. This is also indicated by a “Connection: Close” header that was added to the response (which you can see in image 2 in the lower right pane). Why was the connection closed? The simple answer is because there’s no content-length header in the response. Yeah, so? So, if there’s not content-length header, then the client has no way of knowing when the response is finished and will just keep waiting for more data from the server. Ahh.., but why wasn’t the content-length header added? Well, I have no idea why. What I can tell you is that if your client is going to send another request to your server right after this one, it won’t be able to reuse that connection and will have to open a new one which, in some cases, is just a waste of time. So how do you avoid that? Simple:

context.Response.AddHeader("content-length", "0");

 
Since we’re not sending any content (That’s what a 304 response is all about), we simply add that header. ASP.NET will now realize that the response is actually empty and there’s no reason to close the connection and will not add that header.

Let’s start with a very useless but simple example. Suppose we have an HTTP handler that returns the current time updated to the minute:

public void ProcessRequest(HttpContext context)
{
    DateTime now = DateTime.Now;
    DateTime time = new DateTime(now.Year, now.Month,
        now.Day, now.Hour, now.Minute, 0);
    context.Response.Write(time.ToString("HH:mm"));
}

We just grab the current time, turn it into a DateTime without seconds and send it to the response stream.

Now, Since we only provide the time up to the second, It seems reasonable to tell the client to cache this result and don’t bother us again at least for another.. well for another minute. How do we do that? We set the Expires header:

public void ProcessRequest(HttpContext context)
{
...    context.Response.Cache.
        SetExpires(time.AddMinutes(1));
    context.Response.Write(time.ToString("HH:mm"));
}

This basically tell the client not to bother contacting the server for another minute since there won’t be any changes anyway.

But what will a user do if he’s sure that a minute already passed but the page still displays the old time? He’ll click the Refresh button. The browser will now send the request again and our handler will return the time again.

Since it takes a lot of resources to process that request, we would like our client to send the server something like “I have a cached version of this page from date XY. Do you have a newer version?”. To do that, our client has to know when was this resource last updated. If you’re retuning files, you can use the last modification date of the file. If you’re reading records from a database and you have a “MODIFICATION_DATE” column, you can use that. In our case, we simply return the time itself:

public void ProcessRequest(HttpContext context)
{
...    context.Response.Cache.SetLastModified(time);
    context.Response.Cache.
        SetExpires(time.AddMinutes(1));
    context.Response.Write(time.ToString("HH:mm"));
}

Now, when the user hits the refresh button, the browser will send an  HTTP request with the following header:
If-Modified-Since: Sun, 09 Sep 2007 18:19:00 GMT

All we have to do now, is check whether the client passed this header, check if our data has changed since that time and if nothing has changed, send a 304 response code without sending the data itself:

NameValueCollection headers =
    context.Request.Headers;

DateTime ifMod;
if (DateTime.TryParse(headers["If-Modified-Since"],
    out ifMod))
{
    TimeSpan delta = DateTime.Now - ifMod;
    if (delta < TimeSpan.FromMinutes(1))
    {
        //nothing has changed, return 304
        context.Response.StatusCode = 304;
        return;
    }
}

Great, so what does all this have to do with this post title? This, and more in the next episode of..

The project is exactly what you’d expect: A viewer for JSON strings. The viewer comes in 3 flavors:

1. A standalone viewer – JsonView.exe
2. A plugin for Fiddler 2 (http://www.fiddler2.com) – FiddlerJsonViewer.dll
3. A visualizer for Visual Studio 2005 – JsonVisualizer.dll

[More screen shots]

As you can see above, the viewer simply shows a tree structure representation of the JSON format, But it has a few other cool features:

1. The Text View allows you to format the JSON string to make it more readable. It will also show you when there are errors in the string and try to show where the error is.
2. A simple and easy to use Find dialog let’s you find nodes within the JSON structure.
3. You can customize the viewer with 2 types of plug-ins:
   • Text providers allow you to show a different text representation for a JSON node. In the above screen shot, notice that the @99976124000000@ string is also shown as (Ajax.Net Date: 12/08/2002..)
   • Visualizers allow you to write custom UI that visualizes any JSON object in the way you find most appropriate. In this screen shot, notice how the grid node is shown on the right inside a List View control.

You can download the latest version from here. If you tried it, let me know what you think.

Check it out

The somewhat good news – I’m working on the Delphi 2007 version of VssConneXion and SourceConneXion and things are looking good. I’m still waiting for Delphi 2007 support from one vendor and then I’ll be able to upload a new version – It looks like it will take another week or so.

The project is a multi-tab terminal services (RDP) client that is very simple yet powerful (That’s a standard line in marketing brochures for utilities).

Highlights:

1. Intuitive and simple UI.
2. Manage all your connections in a single location.
3. Allows you to define a group of connections, so you can easily connect to multiple sessions in a click.
4. Grab Input – when you click inside a terminal window, all input is automatically redirected to that terminal, so key like ALT+TAB and the “Windows” key work as expected. Click anywhere outside the terminal window to return the control to the host (If you’re a VMWare user – you know how this feature works).
5. Supports command line parameters to directly open a connection when it starts.
6. Supports a Full Screen mode where the terminal window gets all the screen but moving the mouse to the upper part of the screen still shows the tabs toolbar.
7. More to come soon..

Download it here:
http://www.codeplex.com/Terminals

By the way, If you’re using TFS, you might want to read Dudu’s blog. Don’t be fooled by the name of his blog, He’s actually a very smart guy – The name is just an internal joke.

I know I get many hits to my blog from people looking for a solution to this problem, So I’m linking to his article here. He explains the subject and my solution much better than me..

http://www.codeplex.com/VssConverterGui

Go to http://www.shorterpath.com/develop/spfree/default.asp , and click “download now”. The zip file contains numerous free components from ShorterPath. The SPFilter.pas file contains a function that extracts text from a document using the IFilter interface.

Technorati: IFilter, Delphi