Web Service

Compress Asp.net Ajax Web Service Response - Save Bandwidth

Kazi Manzur Rashid — Sat, 15 Sep 2007 00:09:31 GMT

In this post, I will show you how to compress the Asp.net Ajax Web Service response, To understand the benefits of compression let us start with a simple example, Consider you have an web service which returns a large data like the following:

[WebMethod()]
public string GetLargeData()
{
    using (StreamReader sr = File.OpenText(Server.MapPath("~/DataFile.txt")))
    {
        return sr.ReadToEnd();
    }
}

The web method reads an large text file (around 100KB) and returns it contents. Once we call this method from a page the network activity in the firebug shows like the following:

Now, lets examine the HttpModule which compress the Ajax Web Service response. The following shows the complete code of this module:

using System;
using System.IO;
using System.IO.Compression;
using System.Globalization;
using System.Web;


public class JsonCompressionModule : IHttpModule
{
    public JsonCompressionModule()
    {
    }

    public void Dispose()
    {
    }

    public void Init(HttpApplication app)
    {
        app.PreRequestHandlerExecute += new EventHandler(Compress);
    }

    private void Compress(object sender, EventArgs e)
    {
        HttpApplication app = (HttpApplication)sender;
        HttpRequest request = app.Request;
        HttpResponse response = app.Response;

        //Ajax Web Service request is always starts with application/json
        if (request.ContentType.ToLower(CultureInfo.InvariantCulture).StartsWith("application/json"))
        {
            //User may be using an older version of IE which does not support compression, so skip those
            if (!((request.Browser.IsBrowser("IE")) && (request.Browser.MajorVersion <= 6)))
            {
                string acceptEncoding = request.Headers["Accept-Encoding"];

                if (!string.IsNullOrEmpty(acceptEncoding))
                {
                    acceptEncoding = acceptEncoding.ToLower(CultureInfo.InvariantCulture);

                    if (acceptEncoding.Contains("gzip"))
                    {
                        response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
                        response.AddHeader("Content-encoding", "gzip");
                    }
                    else if (acceptEncoding.Contains("deflate"))
                    {
                        response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
                        response.AddHeader("Content-encoding", "deflate");
                    }
                }
            }
        }
    }
}

Next, register this module in the web.config like the following:

<httpModules>
    <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
    <add name="JsonCompressionModule" type="JsonCompressionModule"/>
</httpModules>

This time the network activity shows like the following:

So by adding this little module, we have saved 74KB. Now consider the impact of this in an highly traffic ajax web application :-). You will find the complete source code in the bottom of this post. If you want to learn more optimization tips check out my previous post Implement Yahoo's YSlow in your Asp.net pages and Combine Multiple JavaScript and CSS Files and Remove Overheads.

Download: Full Source

Utilize ThreadPool in WebService

Kazi Manzur Rashid — Mon, 18 Jun 2007 20:33:58 GMT

Asp.net 2.0 has a built-in feature for creating multi-threaded page AKA AsyncPage, but for Web Service threading, there are no out of the box support. The following code snippet will show you how to create a multi-threaded web service. For the sake of the example, let us assume that we are creating Video Search Service, which will search different sites such as YouTube, MetaCafe, and DailyMotion for a given keyword and returns a composite result. Since this search can be done independently, we can surly invoke separate threads for each search. Let us see how we can utilize the built-in ThreadPool to create a multithread web service.

1 using System;

2 using System.Threading;

3 using System.Collections;

4 using System.Collections.Generic;

5 using System.Web;

6 using System.Web.Services;

9 public class Video

10 {

11 public string Title;

12 public string Author;

13 public string Description;

14 public string Url;

15 public string OriginalUrl;

16 public string Thumbnail;

17 public string Source;

18 }

20 [WebService(Namespace = "http://tempuri.org/")]

21 [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

22 public class VideoSearchService : WebService

23 {

24 public VideoSearchService()

25 {

26 }

28 [WebMethod()]

29 public List<Video> Search(string keyword)

30 {

36 List<Video> result = new List<Video>();

37 List<ManualResetEvent> locks = locks = new List<ManualResetEvent>();

38 ManualResetEvent evt;

40 evt = new ManualResetEvent(false);

41 locks.Add(evt);

42 ThreadPool.QueueUserWorkItem(new WaitCallback(SearchDailyMotion), (object)(new object[] { keyword, result, evt}));

44 evt = new ManualResetEvent(false);

45 locks.Add(evt);

46 ThreadPool.QueueUserWorkItem(new WaitCallback(SearchMetaCafe), (object)(new object[] { keyword, result, evt }));

48 evt = new ManualResetEvent(false);

49 locks.Add(evt);

50 ThreadPool.QueueUserWorkItem(new WaitCallback(SearchYouTube), (object)(new object[] { keyword, result, evt }));

52 //This will ensure that all the threads completes its search

53 EventWaitHandle.WaitAll(locks.ToArray());

55 return result;

56 }

58 private void SearchDailyMotion(object state)

59 {

60 object[] triplet = (object[])state;

62 string keyword = (string)triplet[0];

63 List<Video> result = (List<Video>)triplet[1];

64 ManualResetEvent evt = (ManualResetEvent)triplet[2];

67 //DailyMotion will searhed over here

69 evt.Set(); // Search is complete, so notify the parent thread

70 }

72 private void SearchMetaCafe(object state)

73 {

74 object[] triplet = (object[])state;

75 string keyword = (string)triplet[0];

76 List<Video> result = (List<Video>)triplet[1];

77 ManualResetEvent evt = (ManualResetEvent)triplet[2];

79 //MetaCafe will be searched over here

81 evt.Set(); // Search is complete, so notify the parent thread

82 }

84 private void SearchYouTube(object state)

85 {

86 object[] triplet = (object[])state;

87 string keyword = (string)triplet[0];

88 List<Video> result = (List<Video>)triplet[1];

89 ManualResetEvent evt = (ManualResetEvent)triplet[2];

91 // YouTube will be searched over here

93 evt.Set(); // Search is complete, so notify the parent thread

94 }

95 }

The whole thing has been done in four steps:

Step 1:

We created few variables:

A Generic List of Video which holds the search result
A Generic List of Locks which is actually ManualResetEvent class
A ManualResetEvent class to instantiate for different search.

Step 2:

Starting each Search, this steps are repeated for the 3 different search:

We created an Instance ManualResetEvent class and Adds it in the locks list. ManualResetEvent is special class, which allows us to communicate with different threads by signaling.
Next, we queue a Task in a ThreadPool passing the Keyword, The Result list where the search result will be appended by the child thread and ManualResetEvent. The ThreadPool class method QueueUserWorkItem only takes a WaitCallback delegate which only accepts a single argument of object type and that's way we creating array on the fly and putting these items in that array. When a task is queued in the ThreadPool, the ThreadPool picks a free thread from its pool fires the thread to run the assigned method in that thread.

Step 3:

Inside the Child Thread :

Cast back the argument to proper types.
Search the Site. I have commnted this to make the code shorter
Then call the set() method of the ManualResetEvent. By calling this method, we are sending signal to the parent thread that the thread has done its job.

Step 4:

The parent thread:

The Parent threads call the EventWaitHandle.WaitAll(). This ensures that the parent thread will wait until all the child threads complete its job.

And We are Done!

Few Notes:

It is not possible to access the HttpContext.Current from the Child Thread method which means it also not possible to access the Request, Response, Cache, Session etc. If you need any of these objects in the child thread method then you also have to pass it in the WaitCallback like we did in the above.
Never Creates a New Thread alternatively use the Built in ThreadPool class.
Queuing a Task does not ensure that it will started be instantly, it completely depends upon the current usage of the ThreadPool, if the ThreadPool is already saturated with previous tasks then there might be a chance that your application will perform poorly even comparing with the Single threaded approach.

My First Article

Kazi Manzur Rashid — Sat, 13 Jan 2007 18:14:00 GMT

Recently I wrote an article "How to exchange data securely with a WebService without HTTPS/SSL" in codeproject. If Cryptography, Public/Private Key, Digital Signature and Web Service are one of your interest, I strongly recommend to read it.

Writing Code against the External Service

Kazi Manzur Rashid — Sat, 13 Jan 2007 17:18:00 GMT

When consuming any external service, don't expect the external service developer is as much smart as you are. Recently I have faced an issue when integrating with Amazon S3 that they failed to serve the data on first request, but on the consequent request they are able to return the data. So I did a little tweak in my code, instead of calling the service once, I am retrying up to 3 times. If the retry also fails the regular code block executes:

const int MAX_TRY = 3;
int tryCount = 1;
byte[] result = null;

using(AmazonS3 proxy = CreateServiceProxy())
{
    while(((result == null) || (result.Length == 0)) && (tryCount < MAX_TRY))
    {
        try
        {
            result = proxy.GetObject(_bucketName, key, false, true, true, _accessKeyID, timestamp, true, signature, null).Data;
        }
        catch
        {
            tryCount += 1;

            if (tryCount == MAX_TRY)
            {
                throw;
            }
        }
    }
}

return result;