1. Verify that you have installed ASP.Net AJAX on the server and/or development machine (click here).
   
2. Verify that your Web.Config file has all of the appropriate entries in it for ASP.net AJAX once the package is installed (see here for an example one that works for me).
3. Verify you can add the ScriptManager control to your ASP.Net web form.
   
4. Verify EnablePartialRendering on the ScriptManager is True.
   

I will continue adding more checklist items as I continue to encounter problems people are having via the newsgroups, etc. Feel free to leave a comment on this post and I'll make sure I add it to the main list. Thx.

Recommended reading:

This is technically something you may want to do sometime, especially if you have a webcontrol that is grabbing a stash of data, doing some kind of organzing algorithm on it, and then displaying it to the page. If the webcontrol has any store of data within it (such as a list of items, etc) you may want to "bind" to that data from another control. How?

To do this, I simply created a UserControl that contains a ListBox with some predefined values in it:



I then had the user control implement both IEnumerable and IEnumerator:

public partial class WebUserControl :
    System.Web.UI.UserControl, IEnumerable, IEnumerator
{
    ....
}

From within the IEnumerator code, I enumerate the contents of the ListBox (technically I could probably just return the enumerator for the ListBox within the user control BACK to the object binding to the user control, but that's not exactly the point here, the point is implementing this so someone can generically bind to your user control.

    Int32 _CurrentItem;

    public object Current
    {
        get {
            return this.ListBox1.Items[_CurrentItem];
        }
    }

    public bool MoveNext()
    {
        if ((_CurrentItem + 1) < this.ListBox1.Items.Count)
        {
            _CurrentItem++;
            return true;
        }
        else
            return false;
    }

    public void Reset()
    {
        _CurrentItem = 0;
    }


Now that this is in place, I simply set the data source for some other object (in this case, another ListBox) to the user control:

    protected void Page_Load(object sender, EventArgs e)
    {
        this.ListBox1.DataSource = this.WebUserControl1;
        this.ListBox1.DataBind();
        return;
    }

The result is two listboxes on the page, one inside my user control, with the same content:



Now, as an added twist, how about doing it declaratively? Well, we simply implement IDataSource:

public partial class WebUserControl :
    System.Web.UI.UserControl, IEnumerable, IEnumerator, IDataSource
{
    ...
}

...and now return a DataSourceView object from our class:

    public class MyDataSourceView : DataSourceView
    {
        public MyDataSourceView(IDataSource owner, string name) : base(owner, name)
        {

        }
        public IEnumerable EnumerableObject;
        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
        {
            return EnumerableObject;
        }
    }

    public DataSourceView GetView(string viewName)
    {
        MyDataSourceView dv = new MyDataSourceView(this, "Default");
        dv.EnumerableObject = this;
        return dv;  
    }

    public ICollection GetViewNames()
    {
        ArrayList al = new ArrayList();
        al.Add("default");
        return (ICollection)al;
    }

Most of the meat of the DataSourceView class is unnecessary in this example, so generic strings are past, etc. The result is the same, a fully databound object - but this time it can be done declaratively.
Recommended reading:

You will get this error if the ASP.Net AJAX framework isn't installed properly on your machine (Sys is the root namespace of ASP.Net AJAX), or if your web.config file isn't configured properly to include the properl libraries needed for ASP.Net AJAX to execute on your server.

If you look at your ASP.Net AJAX page, you'll see a series of script/web references being made like this (the hashes change, be aware of that):

<script src="/WebResource.axd?d=3ue6Jup1QMviboHN8KuVNg2&amp;t=632962405372187500" type="text/javascript"></script>

You must be able to paste this reference into your browser and get back a script file; if this does not work then the libraries are not installed, or you don't have the site configured properly for ASP.Net AJAX to operate.

Say you have a situation like this:



Here you see we have a master/content page scenario with the content page containing an UpdatePanel and the master page containing a ScriptManager. If you look at the bottom of the master page, you'll also see a LinkButton creatively named "LinkButton". Within the UpdatePanel on the content page, you'll see a Label.

What we want to do is handle the LinkButton click event asynchronously (through ASP.net AJAX) so that the Label within the UpdatePanel on the content page refreshes seamlessly. The catch, however, is that you want to centralize all your code for handling the click event from within the ContentPage. How would you do this?

First, within the Page_Load event for the MasterPage control, you would do this:

    protected void Page_Load(object sender, EventArgs e)
    {
        this.ScriptManager1.RegisterAsyncPostBackControl(
            LinkButton1);
        return;
    }

You see here that we're registering the LinkButton with the ScriptManager control as one that should generate asynchronous postbacks. We then publicize the LinkButton by actually creating an accessor property for it directly within the code for the MasterPage as follows:

    public LinkButton MyLinkButton
    {
        get
        {
            return LinkButton1;
        }
    }

This let's us interact with the LinkButton on the master page strongly (as opposed to using the FindControl method and locating it "weakly" or by name).

The Page_Load event for the content page, then, will look like this:

    protected void Page_Load(object sender, EventArgs e)
    {
        MasterPage mp = (MasterPage)this.Master;
        mp.MyLinkButton.Click += new EventHandler(OnButtonClick);
    }

We grab a reference to the MasterPage object and type it to our particular variant on the MasterPage class (remember we have modified it to have the MyLinkButton property above). Once we have a valid reference, we use the MyLinkButton reference to grab a reference to the LinkButton itself and register an event handler for its click event from within our ContentPage.

We then actually write the event handler within the ContentPage itself:

    private void OnButtonClick(Object sender, EventArgs args)
    {
        this.Label1.Text = DateTime.Now.ToString();
        return;
    }

The result is a control on the MasterPage firing an asynchronous postback event that is then handled properly from the ContentPage (the arrow in the picture points to the region that was asynchronously updated):

Recommended reading:

This is just darn cool.

How long has this been there...no, wait...don't tell me...I don't want to look like an idiot....

I'm not going to go through a step-by-step tutorial on how to setup a script localization example here because it's done very well on the AJAX.ASP.Net site. One thing that's missing there, though, is a firm understanding of exactly how script localization works under ASP.Net AJAX. Understanding a little about how it all works might also help you understand a few bits about what happens when things go wrong.

First, the basic concept: Script localization means building scripts so that they make sense to the culture of the person using them. It would be *nicer* if someone in Germany saw something in German instead of English, and if someone in France saw something in French instead of German. Localizing something means making it local for the user.

ASP.Net has a system for localizing web pages using a satellite-assembly paradigm where you can add individual language support as totally independent modules that are used when available, or else a default language is used. Now with the introduction of ASP.Net AJAX, the concept is shifting towards more client-centric web design for ASP.Net and therefore the breadth of localizing components is spreading off the server and to the client browser.

Second, the samples: The sample from Microsoft on the subject of localizating ASP.Net AJAX has you build a web site which looks like this:

Here you see a dropdown that says "English". You can also change the language of the page through the dropdown:

....."Okay", you'd say, "But how is this any different from localization in earlier versions of ASP.Net?" You're right. So far nothing has changed. However, if you try to click one of the buttons, you're going to execute a block of script code that produces this (if you're running under Italian):

The script that generated this (the script we wrote) looks like this:

function CheckAnswer()
{
    var firstInt = $get('firstNumber').innerText;
    var secondInt = $get('secondNumber').innerText;
    var userAnswer = $get('userAnswer');

    if ((Number.parseLocale(firstInt) + Number.parseLocale(secondInt)) == userAnswer.value)
    {
        alert(Answer.Correct);
        return true;
    }
    else
    {
        alert(Answer.Incorrect);
        return false;
    }
}

...and THIS is where the ASP.Net AJAX stuff comes into play. Look at how the argument to the alert() method uses this mysterious Answer object to get the strings to use (Answer.Incorrect or Answer.Correct). The Answer object actually refers to a .resx or resource file you generated on the server to hold all the localized strings. How is the script referencing the file and how is it getting the right strings?

You tell ASP.Net AJAX to load the resources needed for a script by using a Web and ScriptResource attribute in your Assembly.XX file (.cs or .vb). Like this (in C#):

[assembly: System.Web.UI.WebResource("LocalizingScriptResources.CheckAnswer.js", "application/x-javascript")]
[assembly: System.Web.UI.ScriptResource("LocalizingScriptResources.CheckAnswer.js", 
      "LocalizingScriptResources.VerificationResources", "Answer")]

You see here that you make a reference to the javascript file CheckAnswer.js in the first attribute as a WebResource. You then make a reference to a resource needed to localize the script via the ScriptReference (the second attribute). In the second attribute you reference a resource for the script with the name VerificationResources on the server, and refer to it as "Answer" on the client. As it turns out, I have two resource files on the server:

VerificationResources.it.resx
VerificationResources.resx

...Or the resource for the Italian and default culture, respectively. When the ASP.net AJAX framework is building the script to return to the client (either as a result of the first page load or a partial postback), it will look at the culture for the calling thread on the server and reference the resource files using the standard ASP.Net 2.0 methodology. It will take all of the resource data out of the resource file it grabs (VerificationResources.it.resx if the thread is running under the Italian culture, or VerificationResources.resx if anything else), package it up as a javascript type and return it to the client. On the client, it is given the name "Answer" in this sample, where the client code can reference it.

A look in fiddler will show an example of the "Answer" class generated for the default culture:

Answer={
"Verify":"Verify Answer",
"Correct":"Yes, your answer is correct",
"Incorrect":"No, your answer is incorrect"
};

If you reload the page and have it generate an Italian page, the fiddler dump will show the following amongst everything else that comes down:

Answer={
"Verify":"Verificare la risposta",
"Correct":"Si, la risposta e’ corretta",
"Incorrect":"No, la risposta e’ sbagliata"
};

When this block gets downloaded, it will change the contents of the type referenced by your script code. This is how localization works under ASP.Net.

 Recommended reading:

Read my previous post.

You can use this method from Page_Load in the following manner (if you want the ASPX page to return an image).

public partial class Default2 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        MemoryStream mem = TransparentGif.DrawTransparentGif(
            "Test", Color.Red, 128, 128);
        Response.Clear();
        Response.BufferOutput = true;
        Response.ContentType = "image/gif";
        Response.BinaryWrite(mem.ToArray());
        Response.Flush();
        return;
    }
}

Recommended reading:

To run script before and after an async postback through ASP.Net AJAX, you do the following:

First, add the ScriptManager to your page.

Second, after the ScriptManager add the following script:

            <script language="javascript">
                var req = Sys.WebForms.PageRequestManager.getInstance();
                req.add_endRequest(OnFinishedRequest);
                req.add_beginRequest(OnStartedRequest);
                function OnFinishedRequest(sender, args)
                {
                    alert('postback done'); 
                }
                function OnStartedRequest(sender, args)
                {
                    alert('postback started');
                }
            </script>

Third, run the ASP.Net app.

add_beginRequest and add_endRequest events are fired when the request is started or has ended, respectively. The result of the above code will be a dialog saying "postback started" when you generate an async postback, followed immediately by "postback done".

Simple enough.

Recommended reading: