Infosys | Microsoft

The problems associated with this model are

i.  Large amount of data is transmitted across wire, multiple times, unnecessarily. The famous postback mechanism transmits the data (all user inputs as well as the hidden viewstate data) to the server for processing. For example, if an employee id is all that is required to pull off the details about him/her from the server side, employee id is not just one input that flows into the server side, in this model.

ii.  Server needs to do a lot of processing, time and again, for creating the content of whole page, by undergoing the ritualistic process of page building (remember HttpRuntime, Handlers, modules, page object etc).

iii.  Rendering the whole page content for just to update its small portion will have unwarranted flickering effect on the user interface.

In the cases of high amount of performance and scalability requirements, first two points should pose a challenge and would get the attention from design and development team. Despite the fact that gauging how much pesky the issue that is related to third point is bit difficult ( as it depends on the characteristics of people that application is catering to ), this issue, in general, continues to be a point of frustration for web application developers and a point of irritation for seasoned web users.

So, how to tackle these problems that are offshoot of server centric, browser based web applications? Again asynchronous programming comes into picture to handle such issues. But, something more other than asynchronous mechanism is needed to tackle them. Enhanced client side functionalities in ASP.NET 2.0 are that something more.

What all required to handle these issues are that external server side call/a web request should be made from client side and server should respond to the client script by not discarding the content of the current page. Then a callback method from client side should be able to update a part of the page’s content through DHTML object model. It means that we do not try to eliminate the round trip to the server completely. But we try to eliminate transmitting unnecessarily large amount of data. Instead of a server control postbacks the web request; here a client side control tries to do that. But this request is of completely different type – callback request rather than to be a normal postback request. ASP.NET runtime understands this distinction so it will not do the significant task, of refresh the the page content completely as it generally does in normal requests. This fact is so important for eliminating the flickering effect or achieving the partial-rendering of the page. If I rephrase it correctly, this fact is so important for achieving the partial partial-rendering of the page . Partial rendering of the page gets fully completed when server side sends the response of the callback page request to the client side script that updates the specific portion of the page by using DHTML object model.

I have developed a sample web page that executes a web service call and updates the result without causing the page to flicker through the usage of script callback mechanism.

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
public partial class _Default : System.Web.UI.Page, ICallbackEventHandler 
{
    string resultStr = string.Empty;
   
    protected void Page_Load(object sender, EventArgs e)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine();
        sb.Append("<script language=\"javascript\">");
        sb.AppendLine();
        sb.Append("function clientCallbackMethod(arg, context)");
        sb.AppendLine();
        sb.Append("{");
        sb.AppendLine();
        sb.Append("document.all['textAreaBio'].value = arg;");
        sb.AppendLine();
        sb.Append("}");
        sb.AppendLine();
        sb.Append("</script>");
        sb.AppendLine();