Click here to monitor SSC
  • Av rating:
  • Total votes: 262
  • Total comments: 14
Dan Wahlin

Enhance your Website with ASP.NET AJAX Extensions

01 May 2007

AJAX (Asynchronous JavaScript and XML) is arguably one of the most hyped technology acronyms around. The primary advantage of using AJAX is that page refreshes can be minimized, allowing users to get the information they need quickly and easily through a more rich and functional interface. Ajax accomplishes this by using JavaScript and an XmlHttp object to send data asynchronously from the browser to the Web server and back. So, although AJAX has a lot of marketing-hype surrounding it, the benefits it offers can't be denied.

Microsoft's ASP.NET AJAX Extensions provide developers with a quick and simple way to add AJAX functionality into any ASP.NET Website, without requiring in-depth knowledge of JavaScript or other AJAX technologies. This article will demonstrate how you can add AJAX capabilities into a new or existing Website by using a new ASP.NET AJAX server-side control called the UpdatePanel. You'll see how the UpdatePanel control can be used to allow portions of a page to be updated without requiring the entire page to be posted back to the server and reloaded in the browser. Additional topics covered include:

  • The role of the ScriptManager control
  • Nesting UpdatePanel controls
  • Triggering asynchronous requests
  • Providing progress indicators to end users
  • Interacting with the UpdatePanel on the client-side, using the PageRequestManager class.

Let's get started by discussing how to get the ASP.NET AJAX Extensions installed and configured.

Installing the ASP.NET AJAX extensions

Before you can use the ASP.NET AJAX UpdatePanel control you need to install the ASP.NET AJAX Extensions, available from, on your development machine. Once installed, a new Website template titled "ASP.NET AJAX-Enabled Website" will appear when you first create a new Website using Visual Studio .NET 2005 or Web Developer Express. Select this template when you want to add ASP.NET AJAX functionality into Web pages.

The ASP.NET AJAX Extensions rely upon special HTTP handlers and modules to handle and respond to asynchronous requests sent from a browser. By creating a new ASP.NET AJAX Website in Visual Studio .NET, a web.config file will automatically be created that contains references to a ScriptResource.axd handler as well as a ScriptModule module. The ScriptResource handler dynamically loads JavaScript files into pages that leverage AJAX features while ScriptModule manages HTTP module functionality that is related to request and response messages.

If you'd like to upgrade an existing Website and add ASP.NET AJAX functionality into it you'll need to ensure that you manually update your site's web.config file with the proper entries. The easiest way to do this is to create a new ASP.NET AJAX-Enabled Website (as mentioned earlier) and then copy the AJAX-specific portions of web.config to your original web.config file. You'll of course need to ensure that the ASP.NET AJAX Extensions are also installed on your production server before deploying the updated site.

Adding AJAX functionality into ASP.NET Web Forms

Before the ASP.NET AJAX Extensions were released, developers had to rely on custom AJAX libraries to AJAX-enable a Web site. While these libraries were quite powerful and worked in cross-browser scenarios, they often required a familiarity with JavaScript, and even XML or Web Service technologies. Some of the frameworks were/are susceptible to CSRF (Cross Site Request Forgery) attacks, whereby a hacker could hi-jack AJAX messages and potentially steal information. Fortunately, the ASP.NET AJAX Extensions offer a secure AJAX framework that includes a new server control called the UpdatePanel that hides JavaScript complexities.

The UpdatePanel control allows you to focus on the functionality of your application rather than on programming and understanding AJAX-specific technologies. It performs asynchronous postback operations that update a portion of a page rather than the entire page itself. This technique is often referred to as "partial-page updates". The UpdatePanel control works by intercepting postback requests triggered by the page and converting them into asynchronous postback calls, which are then sent to the server using the browser's XmlHttp object. It relies on client-side scripts managed by the ASP.NET AJAX framework to perform this asynchronous functionality.

Before using the UpdatePanel control you must first add into your page an important ASP.NET AJAX control, called the ScriptManager. The ScriptManager handles loading all of the necessary client-side scripts that are required by the UpdatePanel and other AJAX controls in order to make asynchronous AJAX calls. You can drag a ScriptManager control onto a page from the VS.NET toolbox or add it directly into the source code as shown next:

<asp:ScriptManager ID="ScriptManager1" runat="server" />

Once a ScriptManager control is added, an UpdatePanel control can then be defined in the page. The UpdatePanel acts as a container in much the same way as the standard ASP.NET Panel control. However, content embedded within the UpdatePanel is wrapped within a template named ContentTemplate. Any content placed within the ContentTemplate is automatically AJAX-enabled. This means that button click or other postback events triggered by controls in the template will be intercepted and converted into asynchronous AJAX calls to the server.

Listing 1 demonstrates how to use an UpdatePanel control in a page in order to AJAX enable a GridView, which allows paging through customer data:

<asp:UpdatePanel ID="UpdatePanel1" runat="server">
        <asp:GridView ID="GridView1" runat="server" CellPadding="4"
          DataSourceID="SqlDataSource1" ForeColor="#333333"
          GridLines="None" AllowPaging="True" AllowSorting="True"
          AutoGenerateColumns="False" DataKeyNames="CustomerID">
                <asp:BoundField DataField="CompanyName"
                  HeaderText="CompanyName" SortExpression="CompanyName" />
                <asp:BoundField DataField="ContactName"
                  HeaderText="ContactName" SortExpression="ContactName" />
                <asp:BoundField DataField="ContactTitle"
                  HeaderText="ContactTitle" SortExpression="ContactTitle" />

Listing 1. Using the UpdatePanel control and ContentTemplate.

As users page through customer records in the GridView control, or sort different columns, the UpdatePanel control automatically handles AJAX-enabling the call resulting in a partial-page update rather than a complete page refresh.

Displaying progress

Although the UpdatePanel is simple to use, you must take the end user into account when using it, especially if you don't know how long an asynchronous postback may take to complete. Long requests may cause an end user to think that their request has failed or hung and they may start the request again, navigate to a different page or even close the browser. The solution is to provide them with a visual progress indicator so that they know that their request is being processed.

The ASP.NET AJAX Framework includes the UpdateProgress control that can be used to provide users with a visual indication of whether or not their request is still being processed. Listing 2 shows an example of using the UpdateProgress control to display an animated image to an end user, while a Web Service is called that retrieves album information.

<asp:UpdatePanel ID="UpdatePanel1" runat="server">
        <asp:TextBox ID="txtArtist" runat="server" />
        <asp:Button ID="btnSubmit" runat="server" Text="Get Albums" />

        <asp:UpdateProgress ID="upProgress" runat="server"
               <img src="Images/loading_animation_liferay.gif" />

        <asp:GridView ID="GridView1" runat="server">
             -- GridView contents omitted for brevity --

Listing 2. Using the UpdateProgress control.

You'll see that the UpdateProgress control has a ProgressTemplate that contains the content to show to the end user, while the UpdatePanel asynchronous postback is processed. Any content type of content (images, flash movies, videos, etc.) can be placed inside of the template. In cases where you'd like the content to take up a fixed amount of space on the page as opposed to dynamically being added, you can set the DynamicLayout property to false.

The UpdateProgress control shown in Listing 2 is embedded directly within the target UpdatePanel. However, it can be embedded elsewhere in the page and linked to the appropriate UpdatePanel by setting its AssociatedUpdatePanelID property to the ID of the UpdatePanel. In cases where quick partial-page updates may occur, and you don't want the UpdateProgress control to show its content, you can set the DisplayAfter property to the number of milliseconds that you'd like it to wait before displaying progress content. DisplayAfter defaults to a value of 500 milliseconds.

Figure 1 demonstrates the end-user effect of using the UpdateProgress control. As the UpdatePanel is being refreshed with album information from a call to the Web Service, a progress indicator is displayed directly below the Artist textbox.

Figure 1. Using the UpdateProgress control to give visual feedback to end users as a call is made to the Web Service.

Nesting UpdatePanel controls

Multiple UpdatePanel controls can be added into a page in cases where different sections need to make AJAX calls to the server to avoid reloading the entire page. In addition to having multiple UpdatePanels in a page, you can also nest UpdatePanels to provide more granular AJAX functionality. For example, you may want to show a GridView control that displays information and allows a user to drill-down into additional details to achieve a master-details style view. Figure 2 shows an example of doing this using two GridView Controls.

Figure 2. Creating a master-details view of customer and order data.

To accomplish this type of master-details view, an UpdatePanel is nested inside of a GridView's ItemTemplate, as shown in Listing 3. As a user clicks the "View Orders" LinkButton, within each row shown in Figure 2, the GridView within the nested UpdatePanel is made visible. Any paging or sorting requests made within the nested UpdatePanel control will cause it to reload new data by making asynchronous AJAX requests, while data in the parent GridView control is left untouched.

<asp:UpdatePanel ID="up" runat="server" UpdateMode="Conditional">

        <asp:GridView ID="GridView1" runat="server" CellPadding="4"
          DataSourceID="SqlDataSource1" AllowPaging="True"
          AllowSorting="True" AutoGenerateColumns="False"
          DataKeyNames="CustomerID" OnRowCommand="GridView1_RowCommand">
                -- Bound fields omitted for brevity --
                <asp:TemplateField ItemStyle-Width="300px">
                        <asp:LinkButton ID="lbOrders" runat="server"
                          Text="View Orders" CommandName="ViewOrders"
                          CommandArgument='<%# Container.DataItemIndex %>' />
                        <asp:UpdatePanel ID="upChild" runat="server"
                                <asp:GridView ID="gvOrders"
                                  AllowPaging="true" PageSize="5"
                                  Visible="false" runat="server"
                                        -- Bound fields omitted --

                        <asp:SqlDataSource ID="sdsOrders" runat="server"
                          ConnectionString="<%$ ConnectionStrings:ConnStr %>"
                                <asp:Parameter Name="CustomerID"
                                  DefaultValue="NULL" />

Listing 3. Creating a master-details view of data using nested UpdatePanel control.

The UpdatePanel control exposes an UpdateMode property that defaults to a value of "Always". This means that any asynchronous request triggered anywhere within the page will cause the UpdatePanel to refresh itself. In cases where this behavior isn't desired, the UpdateMode property can be assigned a value of "Conditional" so that only triggers associated with the control or child controls embedded within the control's ContentTemplate can cause it to be refreshed through an asynchronous postback. Other controls outside of the UpdatePanel will not cause it to be refreshed. Additional information about UpdatePanel triggers is covered in the next section.

The parent UpdatePanel control in Listing 3 has its UpdateMode set to Conditional so that any asynchronous postback operations caused by the nested UpdatePanel or by other controls in the page do not cause the parent GridView control to be refreshed. This minimizes the number of asynchronous postback requests made to the server.

Using triggers

While controls inside of an UpdatePanel control can cause it to perform asynchronous postbacks, other controls defined outside of the UpdatePanel can also act as "triggers" that cause the UpdatePanel to refresh itself with new data. Two types of triggers exist for UpdatePanels including the AsynchronousPostBackTrigger control and PostBackTrigger control.

An AsynchronousPostBackTrigger causes an UpdatePanel's content to be updated asynchronously when a specific control's event is fired such as a Button's click event or a DropDownList's SelectedIndexChanged event. A PostBackTrigger causes a regular postback operation to occur that reloads the entire page. When AJAX-enabling your Websites you'll normally want to use the AsynchronousPostBackTrigger to stop postback operations from occurring.

Listing 4 shows how to define a DropDownList control as a trigger that can perform a refresh of the UpdatePanel's contents. This is done by using the AsynchronousPostBackTrigger control. Notice that the ID of the DropDownList control is defined using the ControlID property, and the event that causes the partial-page update of the UpdatePanel is defined using the EventName property. When the SelectedIndexChanged event fires, an asynchronous postback is made to the server and the UpdatePanel's content is reloaded.

<asp:UpdatePanel ID="UpdatePanel1" runat="server">
        <asp:GridView ID="GridView1" runat="server" AllowPaging="True"
           DataKeyNames="CustomerID" DataSourceID="sdsCustomers">
                -- Column definitions omitted for brevity --
        <asp:AsyncPostBackTrigger ControlID="DropDownList1"
          EventName="SelectedIndexChanged" />


Listing 4. Defining triggers to perform partial-page updates on the contents of an UpdatePanel.

In cases where you'd like to prevent controls defined within an UpdatePanel's ContentTemplate from triggering an asynchronous postback operation, you can set the UpdatePanel's ChildrenAsTriggers property to false and the UpdateMode to "Conditional". Any events raised by child controls in the ContentTemplate of the control will be ignored, while events raised by triggers such as the one shown in Listing 4 will cause a partial-page update to occur, if needed.

Listing 5 shows an example of setting the ChildrenAsTriggers property to false to prevent LinkButtons clicked within a DataList control from updating the contents of an UpdatePanel. While the LinkButtons don't cause the UpdatePanel to refresh itself, they do cause another UpdatePanel defined in the page to be refreshed so that additional details about employees can be shown to the end user (see Figure 3).

<div style="width: 400px">
    <div style="float: left; width: 200px;">
        Territories:<br />
        <asp:UpdatePanel ID="upTerritories" runat="server"
          ChildrenAsTriggers="false" UpdateMode="conditional">
                <asp:DataList ID="dlTerritories" runat="server"
                  CellPadding="4" DataKeyField="TerritoryID"
                  DataSourceID="sdsTerritories" ForeColor="#333333"
                        <asp:LinkButton runat="server" ID="lbTerritories"
                          Text='<%# Eval("TerritoryDescription") %>'
                          CommandArgument='<%#Eval("TerritoryID") %>'
                          Style="text-decoration: none;" /><br />
        <asp:SqlDataSource ID="sdsTerritories" runat="server"
           ConnectionString="<%$ ConnectionStrings:ConnStr %>"
           SelectCommand="SELECT TOP 20 [TerritoryID], [TerritoryDescription]
             FROM [Territories] ORDER BY [TerritoryDescription]">
    <div style="float: right; width: 200px">
        Employees:<br />
        <asp:UpdatePanel ID="upEmployees" runat="Server">
                <asp:DataList ID="dlEmployees" runat="server" CellPadding="4"
                  DataSourceID="sdsEmployees" ForeColor="#333333">
                        <asp:Label ID="NameLabel" runat="server"
                          Text='<%# Eval("Name") %>'></asp:Label><br /><br />
        <asp:SqlDataSource ID="sdsEmployees" runat="server"
           ConnectionString="<%$ ConnectionStrings:ConnStr %>"
           SelectCommand="SELECT Employees.FirstName + ' ' +
           Employees.LastName AS Name FROM Employees INNER JOIN
           EmployeeTerritories ON Employees.EmployeeID =
           EmployeeTerritories.EmployeeID WHERE
          (EmployeeTerritories.TerritoryID = @TerritoryID)">
                <asp:Parameter Name="TerritoryID" />

Listing 5. Using the ChildrenAsTriggers property to stop child control's of an UpdatePanel from triggering an asynchronous postback operation.

The results of this are displayed in Figure 3. When a territory is clicked, employees in that territory will be shown.

Figure 3. LinkButtons defined in an UpdatePanel trigger a separate UpdatePanel to display additional details about employees.

The UpdatePanel where the controls are defined is not updated since the ChildrenAsTriggers property is set to false.

Handling UpdatePanel events on the client

The UpdatePanel control handles all asynchronous requests to the server, so you don't have to worry about writing JavaScript code. This is great from a productivity and maintenance standpoint but there will be times when you want to know when an UpdatePanel request is going to start, or when data has returned and is about to be updated in the page. For example, you may want to access data returned by an UpdatePanel and use it to make another asynchronous postback request. Or, you may want to animate the UpdatePanel as a request is started so that the end user sees what is happening and knows when content in a particular area of a page has been refreshed. All of this can be done by using a JavaScript class provided by the ASP.NET AJAX script library, called the PageRequestManager.

The PageRequestManager lives in the Sys.WebForms namespace in the ASP.NET AJAX script library and allows you to tie into requests and responses processed by one or more UpdatePanels in a page. It's responsible for managing partial-page updates that occur within a page as well as managing the client page life-cycle. By using it you can tie into several different events and act upon them. PageRequestManager also exposes properties and methods that can be used to check if asynchronous requests are in process. It can also be used to abort existing requests and even cancel pending requests.

Events exposed by the PageRequestManager class include initializeRequest, beginRequest, pageLoading, pageLoaded and endRequest. The following table provides more details about these events and when they are fired.




Raised when an asynchronous postback is first initialized. This event can be used to cancel requests in cases where another request is already in process.


Raised when an asynchronous postback begins. This event can be used to animate an UpdatePanel container within a page to provide users with a visual cue that an asynchronous postback request is starting.


Raised after data is received from an asynchronous postback request but before the data is updated in the page. This event can be used in cases where you'd like to change data returned from the server using JavaScript or provide an effect on the UpdatePanel to signify that content is about to be updated.


Raised when data in a page is updated after a synchronous or asynchronous request.


Raised after an asynchronous postback request is completed. Any errors that occurred during the request can be processed here.

To access the PageRequestManager you can call its getInstance() method on the client-side as shown next:

var prm = Sys.WebForms.PageRequestManager.getInstance();

Once the PageRequestManager object is available, you can define event handlers for the different events that it exposes and attach to them. Listing 6 shows how to attach an event handler to the endRequest event and access data returned from the asynchronous postback request.


function EndRequest(sender, eventArgs)
    if (eventArgs.get_error() != undefined &&
        eventArgs.get_error().httpStatusCode == '500')
        var errorMessage = eventArgs.get_error().message;

Listing 6. This code shows how to attach an event handler to the endRequest event of the PageRequestManager.

Once a request is completed, errors are checked and if none are found, data returned by the request is accessed and passed to another method for processing.

Notice that the parameter signature for the EndRequest() event handler mirrors the one found in the .NET framework where the sender of the event as well as any event arguments are passed as parameters. The eventArgs parameter can be used to check if any errors occurred during the request by calling the error property which can be used to access the HTTP status code of the request. If a 500 error is found then the code accesses the error message by calling the message property, marks that the error has been handled and shows the error message to the end user. If no error occurs, a hidden field, named hidField, which is returned from the asynchronous postback, is accessed to get a value needed by a GetMap() method, which is used to display a Virtual Earth map.

The PageRequestManager can also be used to abort or cancel asynchronous postback requests by handling the initRequest event. Listing 7 shows an example of canceling a request in cases where an UpdatePanel is in the process of making a request and the end user is impatiently clicking a Refresh button.

var prm = null;

function Init(sender)
      prm = Sys.WebForms.PageRequestManager.getInstance();
      //Ensure EnablePartialRendering isn't false which will prevent
      //accessing an instance of the PageRequestManager
      if (prm)
          if (!prm.get_isInAsyncPostBack())

function InitRequest(sender,args)
      if (prm.get_isInAsyncPostBack() & args.get_postBackElement().id ==
         'btnRefresh') {
         //Could abort current request by using:  prm.abortPostBack();  
         //Cancel most recent request so that previous request will complete
         //and display
         alert("A request is currently being processed.  Please " +
               "wait before refreshing again.");

Listing 7. This code shows how the PageRequestManager's initRequest event can be used to cancel a pending asynchronous postback request.

The code in Listing 7 starts by accessing an instance of the PageRequestManager in the Application's init phase and ensuring that an asynchronous postback isn't already in progress on the page. If no asynchronous postback is occurring, the InitRequest event handler is attached to the initializeRequest event. Once the InitRequest handle is called, a call is made to the PageRequestManager's isInAsyncPostBack property and the event argument's postBackElement property (the event argument is of type InitializeRequestEventArgs). The isInAsyncPostBack property returns a Boolean value indicating if an asynchronous postback is currently in progress and postBackElement property provides access to the control that triggered the request.

If an asynchronous postback is already in progress and a new request is triggered by a button with an ID of btnRefresh, the pending request is cancelled by assigning a value of true to set_cancel. A message is then displayed to the end user letting them know that a request is already being processed and that they need to wait. The PageRequestManager class can be used to perform several other actions such as animating an UpdatePanel before a request is made and after the response is processed.


The ASP.NET AJAX Framework provides a simple and productive way to add AJAX functionality into new or existing Websites. With a minimal amount of effort you can make your applications perform more efficiently and provide end users with a richer experience than traditional Web applications by using partial-page updates.

In this article you've seen how the ScriptManager and UpdatePanel controls can be used to make asynchronous postbacks from the browser to the server and how different types of triggers can initiate the requests. You've also seen how UpdatePanel controls can be nested to provide a master-details style view of data and how the UpdateMode and ChildrenAsTriggers properties can control how and when an UpdatePanel's content is updated. Finally, you've seen how the PageRequestManager client-side class can be used to notify you of partial-page update requests and responses.

Dan Wahlin

Author profile:

Dan Wahlin (Microsoft Most Valuable Professional for ASP.NET and XML Web Services) is a .NET development instructor at Interface Technical Training ( Dan founded the XML for ASP.NET Developers Web site (www.XMLforASP.NET), which focuses on using XML, ADO.NET and Web Services in Microsoft’s .NET platform. He’s also on the INETA Speaker's Bureau and speaks at several conferences. Dan has co-authored/authored several different books on .NET including ASP.NET 2.0 MVP Hacks and XML for ASP.NET Developers (Sams). When he’s not writing code, articles or books, Dan enjoys writing and recording music and playing golf and basketball with his wife and kids. Dan blogs at and

Search for other articles by Dan Wahlin

Rate this article:   Avg rating: from a total of 262 votes.





Must read
Have Your Say
Do you have an opinion on this article? Then add your comment below:
You must be logged in to post to this forum

Click here to log in.

Subject: Great article
Posted by: Anonymous (not signed in)
Posted on: Saturday, May 5, 2007 at 7:08 PM
Message: congratulations to the Excellent work and very easy explanation for your contribute to this fantastic technology (ASP.NET Ajax).

Subject: hi deer frind
Posted by: Anonymous (not signed in)
Posted on: Tuesday, May 8, 2007 at 1:29 AM
Message: Tanks for your lectures a bout ajaxs
If you can learn me how I can Load mail in the web page for example Gmail in Google?
Tanks a loath

Subject: Great article
Posted by: Anonymous (not signed in)
Posted on: Wednesday, May 9, 2007 at 10:41 AM
Message: Congratulations!

Excellent explanation. Very simple to understand even for beginners.

Subject: Error connecting database
Posted by: Anonymous (not signed in)
Posted on: Saturday, May 19, 2007 at 1:25 AM
Message: An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: SQL Network Interfaces, error: 26 - Error Locating Server/Instance Specified)

Subject: Error connecting database
Posted by: Anonymous (not signed in)
Posted on: Tuesday, May 22, 2007 at 9:58 AM
Message: You might try a quick Google search. A lot of potential solutions are found just by typing the message you list:
to+SQL+Server+2005 2C+this+failure+may+be+caused+by+the+fact+that+under+the+default+settings+SQL+Server+

Subject: Thank you!!!
Posted by: Anonymous (not signed in)
Posted on: Wednesday, May 30, 2007 at 12:08 AM
Message: Great Article! Very easy to follow and provides enought detail to get me going with AJAX.

Thanks again!

Subject: Thank You so much
Posted by: Anonymous (not signed in)
Posted on: Wednesday, June 6, 2007 at 6:11 AM
Message: Good Article

Subject: Useful
Posted by: kavuthami (not signed in)
Posted on: Tuesday, June 12, 2007 at 7:24 AM
Message: AJAX is more useful in myproject

Subject: Please sign in to comment
Posted by: Tony Davis (view profile)
Posted on: Tuesday, June 19, 2007 at 8:26 AM

I'm afraid anonymous comments have been disabled on this article due to relelntless spamming.

I encourage anyone who wants to add a comment or ask a question to sign in (or join in you're not already a member).

The registration process takes 2 mins, requires only a username, email address and password, and is secure. Simple-Talk does not share any details with third parties, under any circumstances.



Subject: Thanks
Posted by: guru (view profile)
Posted on: Tuesday, August 21, 2007 at 5:51 AM
Message: Thanks ,
For providing this helpful information.

Subject: Regarding gridview
Posted by: guru (view profile)
Posted on: Tuesday, August 21, 2007 at 5:55 AM
Message: will u please forward more info about enhancing Gridview using AZAX & ASP.NET

Subject: Great article
Posted by: sameerchachad (view profile)
Posted on: Sunday, December 6, 2009 at 10:17 PM
Message: This is indeed avery good article on Ajax. Very helpful to me.
Thanks a lot Dan.

Subject: It,s really a great work
Posted by: NIRMA (view profile)
Posted on: Thursday, August 19, 2010 at 2:54 AM
Message: Thank You so much
I am a beginner and want to learn something new and great thing just like ur article on Ajax

Subject: Error UpdateProgressDemo.aspx
Posted by: andytran (view profile)
Posted on: Wednesday, September 22, 2010 at 3:44 AM
Message: The request must contain the parameter Signature.
Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.Web.Services.Protocols.SoapException: The request must contain the parameter Signature.

Source Error:

Line 179: [return: System.Xml.Serialization.XmlElementAttribute("ItemSearchResponse", Namespace="")]
Line 180: public ItemSearchResponse ItemSearch([System.Xml.Serialization.XmlElementAttribute("ItemSearch", Namespace="")] ItemSearch ItemSearch1) {
Line 181: object[] results = this.Invoke("ItemSearch", new object[] {
Line 182: ItemSearch1});
Line 183: return ((ItemSearchResponse)(results[0]));


Top Rated

The Compromise Between Development Time and Performance in Data-Driven ASP.NET MVC
 As developers we always want to produce efficient code, but efficient in what – development time or... Read more...

Rethinking the Practicalities of Recursion
 We all love recursion right up to the point of actually using it in production code. Why? Recursion... Read more...

Acceptance Testing with FitNesse: Multiplicities and Comparisons
 FitNesse is one of the most popular tools for unit testing since it is designed with a Wiki-style... Read more...

Acceptance Testing with FitNesse: Documentation and Infrastructure
 FitNesse is a popular general-purpose wiki-based framework for writing acceptance tests for software... Read more...

Prototyping Desktop Deblector
 Deblector is an open-source debugging add-in for .NET Reflector; the Reflector team investigated... Read more...

Most Viewed

A Complete URL Rewriting Solution for ASP.NET 2.0
 Ever wondered whether it's possible to create neater URLS, free of bulky Query String parameters?... Read more...

Visual Studio Setup - projects and custom actions
 This article describes the kinds of custom actions that can be used in your Visual Studio setup project. Read more...

.NET Application Architecture: the Data Access Layer
 Find out how to design a robust data access layer for your .NET applications. Read more...

Calling Cross Domain Web Services in AJAX
 The latest craze for mashups involves making cross-domain calls to Web Services from APIs made publicly... Read more...

Build and Deploy a .NET COM Assembly
 Phil Wilson demonstrates how to build and deploy a .NET COM assembly using best practices, and how to... Read more...

Why Join

Over 400,000 Microsoft professionals subscribe to the Simple-Talk technical journal. Join today, it's fast, simple, free and secure.