After the previous post (Why using jQuery for AJAX calls before the Ajax Control Toolkit)we going to see in this post how you can set up a Web Forms project and how you can easily can create Ajax calls to your code behind.

Setting up the project

Open Visual Studio and create a new ASP.NET Web Application.

Enter a name and a location and click the OK button. Visual Studio will now create a standard Web Forms application. In this example I’m using the .Net 4.0 framework although older versions will work as well (up to 2.0).

When our project is created it will look like this:

As demo we’ll create a simple application that allows the user to add a book to his wish list. The user has to fill his favorite book title. After pressing add we’ll show the added book in a list underneath. The user can add as many book titles as he wishes. Let’s start with updating the Default.aspx page with some text and a textbox where the user can add the book title. Under this textbox we place a button to add the title to the list and the list itself. As you can see this is a VERY simple application where the emphasis lies on the creation of the Ajax call, not the application itself.

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="Demo._Default" ClientIDMode="Static"  %>

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">

</asp:Content>
<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">
  <h2>
        Welcome to ASP.NET!
    </h2>
    <p>
        Enter your book title for your wish list
    </p>
    <asp:TextBox runat="server" ID="txtBookTitle" Width="200"></asp:TextBox>
    <asp:Button runat="server" ID="btnAddBookTitle" Text="Add book title" /><br/>
    <asp:ListBox runat="server" ID="lstBookTitles"></asp:ListBox>

</asp:Content>

One side note: I declared the ClientIDMode Static in the page directive. This will be necessary to implement the jQuery with the same id’s we have given the controls in the aspx page. More info on this blog post of Scot Guthrie.

Our fabulous application now should look like the image below.

Add our business object

In our application we are going to use a class to store our book title information in. In the root of the application add a class. Name this class Book and add the following properties so our class looks like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Demo
{
    public class Book
    {
        public long BooktitleId { get; set; }
        public string BookTitle { get; set; }
    }
}

Reference and create javascript files

In the solution explorer right click on the Scripts folder and choose Add => New item. In the window that appears select a JScript file, name it Default.aspx.js and click ok. Open up our Default.aspx page and add following lines in the HeaderContent block:

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">
    <script src="Scripts/jquery-1.4.1.min.js" type="text/javascript"></script>
    <script src="Scripts/Default.aspx.js" type="text/javascript"></script>
</asp:Content>

This will add the jQuery library and our own created javascript file to the project.

Now we’re ready to start coding.

Create Web Method

To access our code behind file from javascript we have to add a WebMethod. Open up the Default.aspx.cs code file and create the following method:

        public static long AddBook(string bookTitle)
        {

        }

Above these method we can add an annotation to tell the framework we want to access this method directly. Therefor we need the System.Web.Services namespace. Add this namespace in our using declarations:

using System.Web.Services;

Above the method Add Book add [WebMethod(EnableSession = true)]

        [WebMethod(EnableSession = true)]
        public static long AddBook(string bookTitle)
        {

        }

Now we can create the method body. It’s not that much work, we’re going to store the added book titles in a session object.

        [WebMethod(EnableSession = true)]
        public static long AddBook(string bookTitle)
        {
            List<Book> books;
            if (HttpContext.Current.Session[sessionName] != null)
            {
                books = HttpContext.Current.Session[sessionName] as List<Book>;
                if (books == null)
                    books = new List<Book>();
            }
            else
            {
                books = new List<Book>();
            }
            Book book = new Book() { BooktitleId = GetNextBookTitleId(), BookTitle = bookTitle };
            books.Add(book);
            HttpContext.Current.Session[sessionName] = books;
            return book.BooktitleId;
        }

        private static long GetNextBookTitleId()
        {
            if (HttpContext.Current.Session[sessionName] != null)
            {
                List<Book> books = HttpContext.Current.Session[sessionName] as List<Book>;
                if (books != null)
                {
                    long ticket = books.Max(t => t.BooktitleId);
                    ticket++;
                    return ticket;
                }
            }
            return 1;
        }

I’ve created a helper method to get the next available Id so our list can’t contain the same id twice. Build your application and hit Run. Our Default page should open in a browser window without any changes.

Creating our Ajax call in jQuery

Open up the Default.aspx.js file we created. In this file we will add an event handler on the submit button. When the button is clicked we’ll call the code behind method and add the title to the list stored in the session variable. Add the following lines to the file and run the application.

$(document).ready(function () {
    $("#btnAddBookTitle").click(function () {
        alert('Button is clicked !!');
        return false;
    });
});

When you click the “Add book title” button a javascript popup will appear. The return false line will stop the page from executing a post back as we are going to call a ajax method instead.

Adding the ajax call is not more than a few lines:

$(document).ready(function () {
    $("#btnAddBookTitle").click(function () {
        var $bookTitle = $("#txtBookTitle").val();
        $.ajax({
            type: "POST",
            url: "Default.aspx/AddBook",
            data: "{ 'bookTitle':'" + $bookTitle + "' }",
            contentType: "application/json; charset=utf-8",
            dataType: "json",
            success: function (msg) {
            },
            error: function () {
                alert('Error calling AddBook');
            }
        });
        return false;
    });
});

We’ve added a variable $booktitle where we fetch the title that our user has entered in the textbox. After that line we start the ajax call. There are a few settings we’ve got to set before the call will work:

• Type: can be POST or GET, in this case: POST
• url: The url where the values should be posted to: the page name + the method name (“Default.aspx/AddBook”)
• The data: we have to send the booktitle to our code behind method. This we will rap in a JSON format (more info on http://www.json.org)
• ContentType: We declare we want to use JSON to communicate with the server
• Datatype: We declare we want to use JSON to receive data from the server
• Success: what we have to do when the call is succeeded (not filled out yet)
• Error: what we have to do when the call throws an error.(alerting a message box in this case)

This is all we have to add to contact our code behind method. If you run the application and open up Firebug in firefox or the developer tools in Internet Explorer 9 or the developer tools in Google Chrome well see in the NET tab we make a async call to the server and receive the id of the book title we’ve added.

Response: {"d":4}

Implement success function

All we have to do now is add this data to our list view. Therefor we’ll have to implement the success function in our ajax call:

            success: function (msg) {
                var $bookId = msg.d;
                var $option = new Option($bookTitle, $bookId);
                $("#lstBookTitles").append($option);
            }

We create a variable $bookId to store the id in we receive from the server. As you can see the return message is wrapped in a “d” variable. This is changed in the .NET 3.5 version. More info in Dave Ward’s post on Encosia.
After that we create an option to be added in the listbox and append it to this box.

If we run the application now well see that every time a book title is added, it’s send asynchronously to the server. We receive an id from the server and the book title is added to the listbox.

Next post will be about implementing AJAX calls in ASP.NET MVC 3 project.

Every starting developer in ASP.NET who wanted to integrate AJAX functionality in his web application first started with the Ajax Control Toolkit. It’s easy to understand, in Web Forms it’s almost not more than a drag and drop implementation.

After a while you start to notice the limitations. You want to create a functionality that’s not integrated in the toolkit. You start with extending methods, extending properties and get stuck every time again. The amount of update panels start to grow above your head and on every postback you’re have to test if the postback is a Ajax post back or not. In your UI you start to see some disadvantages, the focus is lost when a update panel is updated, you’re page jumps back to the top and so one.

One of the most disturbing issues I found was the load from and to the server. For a simple update of a textbox, the whole content of the update panel is send in the background to update your page. In the first screenshot you see a (very) simple example. The value typed into the textbox has to be added to the list underneath without submitting the page. After creating the update panel and added a script manager we implemented the async postback.

The only thing we needed back from the server is the ID of the value entered and the value itself (although that isn’t needed to make a round trip) I we check the Console or Net tab in Firbug we see the response:

1|#||4|471|updatePanel|UpdatePanel1| <span id="lblFirstName">Bart</span><br /> <span id="lblLastName">De Meyer</span><br /> <span id="Label1">Ticket</span><br /> <input name="txtTicket" type="text" id="txtTicket" /><br /> <input type="submit" name="btnSave" value="Save" id="btnSave" /><br /> <select size="4" name="lstTickets" id="lstTickets">     <option value="1">aaaa</option> </select> |148|hiddenField|__VIEWSTATE|/wEPDwUJNTU0OTM3MDUxD2QWAgIDD2QWAgI DD2QWAmYPZBYCAgsPEA8WAh4LXyFEYXRhQm91bm RnZBAVAQRhYWFhFQEBMRQrAwFn ZGRkfXCqCy7IiEyl+lHROA5vfn1oYNq3t8MhnzZlEt DTPXA=|80|hiddenField |__EVENTVALIDATION|/wEWBALF19m3BALEsPqoBgKct7iSDAKjn6ufDly+66xedWvvj /fQnBQjlOsBTWNL9UuTy1VDVvKmkOGe |15|asyncPostBackControlIDs|| btnSave,btnSave|0|postBackControlIDs|||26|updatePanelIDs||  tUpdatePanel1,UpdatePanel1|0| childUpdatePanelIDs|||25| panelsToRefreshIDs|| UpdatePanel1,UpdatePanel1|2| asyncPostBackTimeout||90|16|formAction||UpdatePanel.aspx| 

A 1024 character response, including all controls that are in the update panel.

For test, I’ve implemented the same functionality with an Ajax call with jQuery. Check the response:

{"d":{"__type":"Webform.Object.Ticket","TickedId":3,"TicketName":"aaaa"}} 

A 73 character response, only containing the values we needed: the id of the value entered and the value entered

As you can see in this (very) simple example, the difference between the implementing a async callback with the toolkit and jQuery gives us an advantage of 951 characters. You can imagine what the difference would be in a page with let’s say 50 controls on their.

For simple Ajax functionality the toolkit is an excellent choice for a beginning developer. A developer who doesn’t want to know what’s going on in the background. He updates a drop down list and the correct value appears in the textbox underneath. What triggered it and how it’s used, he (or she) doesn’t care. They still maintain and renew the toolkit as you can see on Stephen Walter’s blog.

I do care. I’m one of those guys who want to know what’s going on in the background, so I can extend functionality, create my own controls and so one. And I do care about the traffic I generate.