Tanzim Saqib on .NET discovery

In AJAX based applications its common that user might end up breaking your AJAX calls by clicking on numerous places in very short interval of time. Let us assume there is a page where there are several of hyperlinks which make WebService calls and do some stuffs on callback. If user clicks on five hyperlinks being impatient or may be just for fun, there will be five different WebService calls made. All of those calls had the same parameters or UI state while they were invoked. But on completion of one or more WebService calls it may happen that the UI state or data passed to the rest of the WebServices calls no longer exist or expired, thus will be result in inconsistent UI behaviour and/or invalid data. This is one of the important scenarios an AJAX developer should consider when he designs an application.

The Specification
To address the scenario, I would prefer implementing a Sequential WebService Calls Queue which will be able to schedule the tasks/WebService calls and help keeping UI and data consistent over the AJAX calls. We should achieve the following features from this queue:

• Enqueue any WebService call anytime in the application.
• Dequeue any previously queued call regardless of currently executing call and location in the application.
• Each WebService call should have an identifier so that we can track the call and dequeue anytime later by SSQ.dq(call_id).
• Each call should have a timeout value which will determine the maximum amount of time we will consider for that particular call before we invoke the next call, after that we will remove from the queue.
• A timer will act as scheduler but will not run forever. It should run only when necessary.
• Each call should be able to declare its completion at any time by notifyCompleted, so that the scheduler timer will not wait for the prior task and should dequeue the next call.
• notifyCompleted should also be optional. The currently running call should automatically be dequeued from the scheduler queue after the timeout of its own.
• Each call should be able to mark as replaceIfExists so that if user`s any activity already enqueued this call, should be replaced by the current one.
• The queue instance should be exclusively available to the user and all over the page, meaning that the same queue class will be used to serve the functionality in one page per user basis.

The Usage
You should be able to use this library as follows:

1. Include GenericQueue.js and SequentialServiceQueue.js to your project
2. Add the reference in the pages that you want them to be used

We will be naming the class as SequentialServiceQueue and in short SSQ. Let us have a look at the WebService calls in Service Queue fashion:

var id1 = SSQ.nq('SomeMethod1', false, 1000, 
    function() 
    {
        // Do some stuffs
        SomeWebService1.SomeMethod1(SomeParameters, onSomeMethodCallCompleted);
    });

function onSomeMethodCallCompleted(result)
{
    // Do stuffs
    SSQ.notifyCompleted(id1);    
}

var id2 = SSQ.nq('SomeMethod2', false, 1000, 
    function() 
    {
        // Do some stuffs
        SomeWebService2.SomeMethod2(SomeParameters, 
            function(result)
            {
                // Do stuffs
                SSQ.notifyCompleted(id2);
            });
    });

You can not only queue WebService calls, but also regular JavaScript codeblock:

var service_id1 = SSQ.nq('Service1', false, 1000, 
    function() 
    {
        // Do some stuffs
        SSQ.notifyCompleted(service_id1);
    });

The GenericQueue
To accomplish the SequentialServiceQueue, first of all we should define an all purpose GenericQueue class which will able to handle any queue requirement out of the box. The queue is fairly simple, just like old Computer Science data structure class. Here are few of the functions from the class:

this.nq = function(element) 
{
    array.push(element);
    ++rear;
}

this.dq = function() 
{
    var element = undefined;

    if (!this.is_empty()) 
    {
        element = array.shift();
        --rear;
    }

    return element;
}

this.for_each = function(func)
{
    for (var i = 0; i < rear; ++i)
        func(i, array[i]);
}

this.delete_at = function(index) 
{
    delete array[index];

    var i = index;
    while (i < array.length) 
        array[i] = array[++i];

    array = array.slice(0, --rear);
}

The SequentialServiceQueue
The following is how this class starts. You will notice here that the timer_id is for our scheduler timer, running_task indicates the currently executing call, interval is a variable for the timer_id which you can determine as your wish. interval is the knob of how fast or slow you want the scheduler to run. queue as you can understand is an GenericQueue instance we have just created above. Note that the GenericQueue is not a static class rather its a instance class unlike the SSQ. You have also noticed that the ms_when_last_call_made and ms_elapsed_since_last_call are pretty self-describing. get_random_id is reponsible for preparing new id for the newly enqueued call.

var SequentialServiceQueue =
{
    timer_id: null,
    ms_when_last_call_made: 0,          // milliseconds (readonly)
    ms_elapsed_since_last_call: 0,      // milliseconds (readonly)
    running_task: null,
    interval: 10,                       // milliseconds
    queue: new GenericQueue(),

    get_random_id: function() {
        var min = 1;
        var max = 10;
        return new Date().getTime() + (Math.round((max - min) * Math.random() + min));
    },

From the code below, as soon as any new call is enqueued, we check for if it is allowed to replace if already exists in the queue with the same name. If found any, we just update that, otherwise we create a brand new task and enqueue and start our updater which is the scheduler in our case.

nq: function(name, replaceIfExists, timeout, code) {
    var id = this.get_random_id();

    if (replaceIfExists) {
        var isFound = false;
        this.queue.for_each(
            function(index, element) {
                if (element !== undefined && element !== 'undefined' && element.name == name) {
                    element.id = id;
                    element.replaceIfExists = replaceIfExists;
                    element.timeout = timeout;
                    element.code = code;
                    isFound = true;
                }
            });
    }

    // Enqueue new task
    if (!isFound || !replaceIfExists) {
        this.queue.nq(
            {
                id: id,
                name: name,
                replaceIfExists: replaceIfExists,
                timeout: timeout,
                code: code
            });
    }

    // We have got new tasks, start the updater
    this.startUpdater();

    return id;
},

The following is the core part of the class which is the scheduler. Inside startUpdater, it executes the block of code in every interval we defined before. And inside the looping code, we check for if there is already any running task, if yes we check for the timeout whether it should make a good timeout or not. Otherwise we let it run as it was. However, if there is no running task at this moment, we dequeue a task and start executing the code and set a starting time for that to keep track of how long it is being running.

detachTask: function(id) {
    this.dq(id);
    this.running_task = null;
    this.ms_when_last_call_made = 0;
    this.ms_elapsed_since_last_call = 0;

    // See if we are done with the queued tasks
    if (this.queue.is_empty())
        this.stopUpdater();
},

startUpdater: function() {
    var _self = this;
    if (this.timer_id == null) {
        this.timer_id = setInterval(
            function() {
                if (_self.running_task == null) {
                    // We dont have any running task, lets make the first one
                    _self.running_task = _self.queue.dq();
                    if (_self.running_task != null) {
                        _self.ms_when_last_call_made = new Date().getTime();
                        _self.running_task.code();
                    }
                }
                else {
                    // We have a running task already
                    _self.ms_elapsed_since_last_call = new Date().getTime() - _self.ms_when_last_call_made;

                    // Should the current task be skipped?
                    if (_self.ms_elapsed_since_last_call > _self.running_task.timeout)
                    // Time's up. leave the task alone. Let other tasks start executing.
                        _self.detachTask(_self.running_task.id);
                }
            }, _self.interval);
    }
},

stopUpdater: function() {
    if (this.timer_id != null) {
        clearInterval(this.timer_id)
        this.timer_id = null;
    }

    this.queue = new GenericQueue();
},

Keep an eye on my blog for continued development and improvements, and download CallQueue from: http://code.msdn.microsoft.com/callqueue

I am not sure about how you guys feel about your IDE look & feel. First few years it was alright for me. However the more I used Visual Studio, the more I experienced problem with my eyes as well as monotony of the same old white background IDE. So, I made a dark theme of Visual Studio which stopped hurting my eyes again. I also tried to keep the syntax yet readable and make careful selection of colors so that important IDE benefits of syntax highlighting was not overlooked. I also tried to avoid absolutely black background, because that demands your eyes to have extra attention to the text since they were prepared to see nothing. So I choose deep navy blue so that it does not hurt your eyes as well as gives your eyes an impression that there may be few things on the screen to read. You may not find it friendly to your eyes, because I am kind of biased to Blue, since its my favorite. You can download the theme from here.

C# View:

HTML View:

XML View:

Good thing about this theme is it only overrides your Text editor's Font and Color, all other settings of your Visual Studio will remain same. Before you apply this theme to your Visual Studio, you may want to export your current IDE settings, so that you can get back to your old one anytime. To export your current settings and look & feel, use Tools > Import & Export settings. Even if you forget to have a backup, you can reset your IDE settings through that Wizard and will get back Visual Studio factory settings.

Windows Azure was announced on PDC 2008 (Oct 27) and will hopefully be released mid next year. You probably already know about Azure by this time. If no, I would like to quote some from www.azure.com as intro: The Azure Services Platform is an internet-scale cloud computing and services platform hosted in Microsoft data centers. The Azure Services Platform provides a range of functionality to build applications that span from consumer web to enterprise scenarios and includes a cloud operating system and a set of developer services. Fully interoperable through the support of industry standards and web protocols such as REST and SOAP, you can use the Azure services individually or together, either to build new applications or to extend existing ones.

Let us have a quick overview of the clients we usually use in our daily life, then we will explore the potential of Azure and what is waiting for us down to the road:

Windows Client

• Full capabilities, power, rich UI, high performance
• Ability to utilize local resources e.g. audio, camera.
• Capable of blending different hardware and software resulting in amazing applications
• Private data, reliable and fastest
• Personal, trusted and full control

Web Client

• Data accessibility, availability
• Connect with devices, data services, friends
• Sociability, ability to share
• Interaction, collaboration, email, instant messaging
• Searchable
• Data security is questionable
• Open formats and standards for data exchange

Mobile Client

• Low capability compared to regular PC horsepower
• Portable: palm reach
• Smart device while powered by web. e.g. Search for restaurants nearby
• Your 24/7 companion

Smart Client

Did we forget about Smart Clients? These applications are usually Windows Forms application which take all the advantages of Windows Client including offline storage, utilization of local resources as well as the goodness of internet connectivity. The Smart Client was coined few years ago, but for .NET developers all Windows Client is pretty much generally considered as Smart Clients. The idea behind Smart Client was to utilize full local computing capabilities and exploit the web's accessibility, availability and nature of openness through XML Web Services to developers build great software.

Mesh

An important part of Live Services is Mesh, which enables developers to build application for consumer devices which are physically close to them. If you are at home you would be able to access through Windows Client, if you are on the go, you would be through Mobile Client, if you have Internet access only, you would be able to avail the service through Internet. Mesh allows us to get all those devices get connected, exchange data and stay synchronized. You can even add a Mac as device into Mesh to work with. Data communication among devices through Mesh is secured, since the data transferred between them are surely encrypted.

The following screenshots show how you can sync your local PC using Mesh and how your friends can share files or work on files you gave access them to:

Goodness of all Clients

Windows Azure Services Platform is actually an array of technologies, consists of set of tools, and extremely scalable on demand powered by Microsoft datacenters and their ingenious virtualization technology. The core of this platform is to provide user with best experience taking the goodies of each client platform we use in our daily life. Combining the power of HTTP, XML, REST and WebServices Azure lets developers to build cloud enabled applications. The basic advantage of using open and standard protocol for communicating between clients is decreased dependency on the tools, languages or platform of the client. Client could be made by Ruby, Python or it could be in iPhone.

Azure enables you to store your data in the cloud. No matter which client you used to work on your data, if you change your client, time-space, you will be able to get back to the same data once you worked on some other devices/OS.

Why hosting cloud application with Microsoft?

Microsoft has 460 millions Live users to date backed up by hundreds of thousands of servers in their datacenters. How many times have you seen Microsoft's sites down? I have not seen many times in life. So, their ability to host, manage super scalable and high traffic websites is not questionable at all. Who else can be a better host of your next big application other than Microsoft?

Planning to move to the Azure Cloud, but already tied to the Membership API? I have recently written an article on Windows Azure which guides you to build a complete Membership provider library which can be leveraged by existing application to link to Microsoft’s cloud platform Windows Azure with no friction. Goals of this project were to be able to use regular ASP.NET Login controls, existing Membership code e.g. Membersip.UpadateUser(), MembershipUser.ChangePassword().

Last, but not least one of the major goals was ease of use. No matter which suite of controls you use: ASP.NET AJAX or MVC, Cloudship can be leveraged as your Membership provider. To install it, into your existing application, simply:

1. Reference the DLL
2. Insert few lines inside web.config
3. You are good to go

In this article you will learn how to implement your own Membership API, thus you can start moving you application data to the Azure Cloud – the future of development and business with Microsoft. Here you go - Cloudship: Membership Provider for the Cloud.

Windows Azure is an upcoming operating system for the cloud from Microsoft, announced on October 27 at PDC. Windows Azure provides developers with on-demand compute and storage to host, scale, and manage Web applications on the Internet through Microsoft data centers. Azure goes beyond what other providers, such as Rackspace's Mosso or Amazon's EC2, offer. First, it will be available with a complete suite of tools and technologies for building your next big cloud application. Second, the Azure platform's goal is to support all developers and their choice of IDE, language, and technology; meaning that you can use your favorite tools for all kinds of development as well as Python, PHP, Ruby, Eclipse and so on. It supports popular standards and protocols including SOAP, REST, and XML. Using the Windows Azure tools, developers can build, debug, and deploy to Windows Azure directly from their existing development environment.

I have written an article "Building applications for Windows Azure" which will walk you through the steps to build an application from scratch on the recently released Windows Azure CTP, Microsoft’s answer to cloud computing. This application will let users add tasks into their Todolists and track them at a later time. The objective of this application is not to use any local data storage like SQL database. Instead, it will store and retrieve data from the cloud which means no matter which language/platform you write your application on, it will be able to access the data. For instance, if you would like to develop an iPhone application which will be able to play with your saved tasks on the go, you will be able to do so. Hope you will enjoy the article.

Link: http://dotnetslackers.com/articles/aspnet/Building-applications-for-Windows-Azure.aspx