After finally getting on the phone with someone who was experiencing the issue, I was able to determine the issue was related to a JS error. ‘AJAXControlToolkit’ is undefined. GREAT, but WHY???

SIDE NOTE: We were very early adopters of the toolkit during its beta stages. MS was great with helping to resolve issues as well as incorporate our feedback in future releases. One of those items was the script combiner in the library. The toolkit is VERY heavy when it is not compressed (~500k) based on what controls you are using. This amounts to 14 different scripts being pulled down on our servers which is one for every control type and a few for the framework itself. As you can guess, this is pretty taxing on the client vs. just getting one file. We manually implemented the script combining on our customer site which took 3 seconds off the average download time due to less items having to be called from the server. Not to mention compression that took the ~500k script to ~90k. With the following in the latest release you can do this without having a manual work around.

The problem

Bad
<ajaxtoolkit:ToolkitScriptManager ID="_ScriptManager"
     runat="server" combinescripts="true" />

Great right? Wrong… this is what was causing the issue!!! The script combiner for some reason doesn’t always generate the script for the client. It is pretty buggy actually. We were finding that clearing the users cache would only work until the next build would come out. After that, we would have to clear the cache again for all 400 clients. Because of this we were ready to scrap the controls (which MADE the application) for standard ASP.NET controls.

So, the workaround… go back to our standard hack that combined the files… and for those that don’t want to do the hack? Switch the combinescripts tag to true and your problem will go away!

The fix:

Good
<ajaxtoolkit:ToolkitScriptManager ID="_ScriptManager"
     runat="server" combinescripts="false" />

Needless to say, this was a big “phew” from us. We believe the framework has a lot of great potential for internal apps by allowing us to have a windows like feel without the deployment nightmare. The application has already proved to have a huge payoff with this fix alone. We were able to deploy enterprise wide in less than 10 seconds with an automated build.

Let’s start with a simple object:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace JSONCookie.Customer
{
    [Serializable]
    public class Address
    {
        private Guid _id;
        private string _address1;
        private string _address2;
        private string _city;
        private string _state;
        private int _postalCode;
        private DateTime _lastUpdated;
 
        public Guid ID
        {
            get { return _id; }
            set { _id = value; }
        }
 
        public string Address1
        {
            get { return _address1; }
            set { _address1 = value; }
        }
 
        public string Address2
        {
            get { return _address2; }
            set { _address2 = value; }
        }
 
        public string City
        {
            get { return _city; }
            set { _city = value; }
        }
 
        public string State
        {
            get { return _state; }
            set { _state = value; }
        }
 
        public int PostalCode
        {
            get { return _postalCode; }
            set { _postalCode = value; }
        }
 
        public DateTime LastUpdated
        {
            get { return _lastUpdated; }
            set { _lastUpdated = value; }
        }
    }
}

As you can see the above is a very simple object with strings, int, Guid, and DateTime fields just to show how the data looks when converted. Now, say you want to store this object into a cookie*. How would we get it to the text level we need for cookie use? There are many articles out there on how to compress a cookie using .NET’s MemoryStram and DeflateStream compression, but all have been showing how to do this with the XML provided back from serialization of an object.

Here is are the two methods I will be comparing:

/// <summary>
/// Here we are just doing plain 'ol serialization
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <returns>Serialized object as string</returns>
public static string SerializeIt(object obj)
{
    XmlSerializer ObjSerializer =
        new XmlSerializer(typeof(Customer.Address));
 
    TextWriter XMLObject = new StringWriter();
    ObjSerializer.Serialize(XMLObject, obj);
 
    return XMLObject.ToString();
}
 
/// <summary>
/// Here we take an object and Serialize it into JSON
/// </summary>
/// <param name="obj">Object to be serialized</param>
/// <returns>JSON string</returns>
public static string JSONit(object obj)
{
    StringBuilder JSONObject = new StringBuilder();
 
    JavaScriptSerializer JSON = new JavaScriptSerializer();
    JSON.Serialize(obj, JSONObject);
 
    return JSONObject.ToString();
}

Now, let’s see what the results are:

Serialized

<?xml version="1.0" encoding="utf-16"?>
<ArrayOfCustomer
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Customer>
    <ID>83a8e9c8-dc2c-4ba7-a17d-86a7f0d1820b</ID>
    <Name>Carina</Name>
    <Blah>Alberto</Blah>
    <Addresses>
      <Address>
        <ID>26c71b32-6e91-4663-b740-81893c28939d</ID>
        <Address1>4957 Isabela</Address1>
        <Address2>Apt: 200</Address2>
        <City>Jaylyn</City>
        <State>Camden</State>
        <PostalCode>95638</PostalCode>
        <Updated>2007-09-28T16:37:26.9334017-07:00</Updated>
      </Address>
      <Address>
        <ID>156e4962-f810-4b7c-be39-6bb07f70989b</ID>
        <Address1>55114 Josephine</Address1>
        <Address2>Apt: 625</Address2>
        <City>Jermaine</City>
        <State>Konner</State>
        <PostalCode>31317</PostalCode>
        <Updated>2007-09-28T16:37:26.9334017-07:00</Updated>
      </Address>
      <Address>
        <ID>5cce9640-95d0-4579-b248-abce62c2225f</ID>
        <Address1>2940 Lillie</Address1>
        <Address2>Apt: 208</Address2>
        <City>Jonas</City>
        <State>Cael</State>
        <PostalCode>31946</PostalCode>
        <Updated>2007-09-28T16:37:26.9334017-07:00</Updated>
      </Address>
      <Address>
        <ID>85655341-4a98-41d8-8cae-155bf902240b</ID>
        <Address1>80959 Giovani</Address1>
        <Address2>Apt: 872</Address2>
        <City>Jade</City>
        <State>Keshawn</State>
        <PostalCode>98534</PostalCode>
        <Updated>2007-09-28T16:37:26.9334017-07:00</Updated>
      </Address>
      <Address>
        <ID>7718ea1c-3282-47b1-9f1f-b546ca905a61</ID>
        <Address1>76381 Maia</Address1>
        <Address2>Apt: 367</Address2>
        <City>Graham</City>
        <State>Natalie</State>
        <PostalCode>79905</PostalCode>
        <Updated>2007-09-28T16:37:26.9334017-07:00</Updated>
      </Address>
    </Addresses>
  </Customer>
</ArrayOfCustomer>

JSON’ized

[{"ID":"83a8e9c8-dc2c-4ba7-a17d-86a7f0d1820b","Name":"Carina","Blah":"Alberto","Addresses":[{"ID":"26c71b32-6e91-4663-b740-81893c28939d","Address1":"4957 Isabela","Address2":"Apt: 200","City":"Jaylyn","State":"Camden","PostalCode":95638,"Updated":"\/Date(1191022646933)\/"},{"ID":"156e4962-f810-4b7c-be39-6bb07f70989b","Address1":"55114 Josephine","Address2":"Apt: 625","City":"Jermaine","State":"Konner","PostalCode":31317,"Updated":"\/Date(1191022646933)\/"},{"ID":"5cce9640-95d0-4579-b248-abce62c2225f","Address1":"2940 Lillie","Address2":"Apt: 208","City":"Jonas","State":"Cael","PostalCode":31946,"Updated":"\/Date(1191022646933)\/"},{"ID":"85655341-4a98-41d8-8cae-155bf902240b","Address1":"80959 Giovani","Address2":"Apt: 872","City":"Jade","State":"Keshawn","PostalCode":98534,"Updated":"\/Date(1191022646933)\/"},{"ID":"7718ea1c-3282-47b1-9f1f-b546ca905a61","Address1":"76381 Maia","Address2":"Apt: 367","City":"Graham","State":"Natalie","PostalCode":79905,"Updated":"\/Date(1191022646933)\/"}]}]

The JSON version is a little more difficult to read, but honestly, who cares… that isn’t your job, you use .NET for that. Now this is great, but not really all that helpful. We currently have one customer with 5 addresses and a lot of data… we could just jamb this into a cookie, but that would actually present some more format issues and to fix them we would nee to take up more space. So… let’s compress. I have attached the project for this so you can try it out and see how the compression works. From here… just put it into your cookie. Here are some interesting stats.

* This data is just an easy example of what you can do to cram into a cookie. Customer data is a very bad example as you wouldn’t want to make this information public even if just session based. There are many other applications for this to utilize the power of the client machine vs. relying on IIS to maintain state on your entire application. This is actually a mini db at the client level. Just make sure you realize how mini… 4kb total… or so they say. Still haven’t broken this with slightly larger cookies in most mainstream browsers.

- JSON Cookie Example (.NET 2.0)

Simple solution! Close all of your open docs that you are no longer using. The compile time will drop dramatically!

Word,
Matt