An ASP.NET Web service is Microsoft’s implementation of Web services in the .NET Framework. An ASP.NET Web service is a .NET class that has certain methods and properties that can be accessed across a network.

You create an ASP.NET Web service by marking certain methods and properties of a class with the WebMethod attribute. That’s all you have to do. After you have marked a method as a Web method, the method can be invoked over the network. If the Web server is on the Internet, the method can be invoked from anywhere in the known universe.

For example, suppose that you want to create a Fortune Web service. This Web service will randomly return your fortune. You can implement this Web service with the following class:

C#. 

using System;
using System.Web.Services;

namespace myApp
{
  public class FortuneService
  {

    [WebMethod]
    public string GetFortune()
    {
      Random objRand = new Random();
      switch (objRand.Next(3))
      {
        case 0:
          return "Things look bad!";
    case 1:
      return "Things look good!";
    default:
      return "Stay home and hide!";
      }
    }

  }
}

VB.NET. 

Imports System.Web.Service

Public Class FortuneService
    Inherits System.Web.Services.WebService

    <WebMethod()> Public Function GetFortune() As String
        Dim objRand As New Random()
        Select Case objRand.Next(3)
            Case 0
                Return "Things look bad!"
            Case 1
                Return "Things look good!"
            Case Else
                Return "Stay home and hide!"
        End Select
    End Function

End Class

Notice that all that you need to do to implement the Fortune Service is to create a .NET class. This class has one method exposed as a Web method—GetFortune(). All the rest of the work of getting Web services to function is taken care of behind the scenes by the .NET Framework.

As you saw in the previous section, creating a Web service is very easy. Just create a class and decorate certain methods and properties with the WebMethod attribute.

In this section, you’ll learn how to invoke a Web service. Visual Studio .NET also makes this process very easy. The development environment takes care of all the messy details of generating the necessary code to communicate with the Web service across the network for you.

When reading this section, it helps to pretend that we are trying to communicate with a Web service in Australia (if you happen to live in Australia, think of New Jersey). Suppose that you want to invoke the Math Service from a Web Form Page to add two numbers together. To do this, the only information that you need from the Australian Web service is the WSDL file. Remember that you can always retrieve the WSDL file for an ASP.NET Web service by appending the query string ?WSDL to the URL for the Web service.

Let’s go ahead and do this in Visual Studio .NET:

When you complete these steps, Visual Studio .NET will automatically retrieve the WSDL file from the Math Service and generate something called a Web service proxy class. The Web service proxy class acts as a local representation of the remote Web service class.

After you retrieve the WSDL file, you should see a new folder named Web References in the Solution Explorer window. There should be a Web reference named localhost in this folder. This Web reference contains the proxy class for the Math Service.

You can view the contents of the proxy class itself by selecting Show All Files from the Project menu, expanding localhost in the Solution Explorer window, and expanding the Reference.map file. Hiding behind the Reference.map file, you’ll discover a file named Reference.cs or Reference.vb. This is the Web service proxy class. Double-click it to view its contents.

The Math Service proxy class has the following three methods:

The easiest method of invoking the remote AddNumbers method of the Math Service is by simply calling the AddNumbers method of the proxy class. You’ll use the other two methods only when you need to interact with a Web service asynchronously (asynchronous Web services are not discussed in this book).

Let’s go ahead and add the proxy class to a Web Form Page:

If you enter numeric values into the two TextBox controls and click the button, the values are passed to the remote Web service. The response from the Web service is displayed in the Label control.

When you create a Web service, you should supply it with a unique namespace. That way, if two companies create a Web service with the same name (for example, two Web services named MathService.asmx), there is still a way to distinguish between them.

You can supply any string for a namespace. However, it is a good idea to use the URL for your company as the namespace because you know that this URL will be unique.

You add a namespace to a Web service class by using the WebService attribute before the class declaration as in the following:

C#. 

[WebService(Namespace="http://yourDomain.com/webservices/")]
public class MathService
{
  ...
}

VB.NET. 

<WebService(Namespace:="http://yourDomain.com/webservices/")> Public Class MathServicea
  ...
End Class

You might be wondering about what happens when you attempt to call a Web method from a Web service and the Web service is unavailable. In that case, by default, your Web Form Page will wait 90 seconds for the Web method to timeout and then the Web Form Page will display a “This operation has timed out” error message.

90 seconds is a long time to keep a user waiting for a response. You can change the timeout period for a Web service proxy by modifying the value of the Timeout property as follows:

C#. 

localhost1.HelloService objService = new localhost1.HelloService();

objService.Timeout = 10000;

try
{
  Label1.Text = objService.SayHello();
}
catch
{
  Label1.Text = "Web service unavailable!";
}

VB.NET. 

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
 MyBase.Load
  Dim objService As New superexpert.HelloService()

  objService.Timeout = 10000
  Try
    Label1.Text = objService.SayHello()
  Catch
    Label1.Text = "Web service unavailable!"
  End Try
End Sub

The Timeout property accepts a value in milliseconds. In this code, the Web service proxy class is set to timeout after 10 seconds (10,000 milliseconds).

Most likely, if you are using a Web service to publish a catalog of products, your list will not change very often. In that case, you should take advantage of caching to reduce the load on your Web server.

There are two ways that you can cache the data returned by a Web method. You can use the WebMethod attribute to enable caching for a particular Web method. Alternatively, you can use the Cache object.

The WebMethod attribute has a property called CacheDuration. You can use the CacheDuration property to cache the output generated by a WebMethod for a certain number of seconds. The following is an example of how this property can be used with a Web method that returns the current time:

C#. 

[WebMethod(CacheDuration=30)]
public string GetTime()
{
  return DateTime.Now.ToString( "T" );
}

VB.NET. 

<WebMethod(CacheDuration:=30)> Function GetTime() As String
  Return DateTime.Now.ToString("T")
End Function

The GetTime() Web method in this case will cache its output for 30 seconds.

As an alternative to using the CacheDuration property, you can use the Cache object. (To learn more about the Cache object see Chapter 14, “Improving Application Performance with Caching.”) The advantage of using the Cache object is it can be used to cache the same data across multiple Web methods.

The following shows how you can use the Cache object in a Web method:

C#. 

[WebMethod]
public DataSet GetCachedProducts()
{
  DataSet dstProducts =
    (DataSet)Context.Cache[ "Products" ];
  if (dstProducts == null)
  {
    dstProducts = new DataSet();
    sqlDataAdapter1.Fill( dstProducts );
    Context.Cache[ "Products" ] = dstProducts;
  }
  return dstProducts;
}

VB.NET. 

<WebMethod()> Function GetCachedProducts() As DataSet
  Dim dstProducts As DataSet

  dstProducts = Context.Cache("Products")
  If dstProducts Is Nothing Then
    dstProducts = New DataSet()
    SqlDataAdapter1.Fill(dstProducts)
    Context.Cache("Products") = dstProducts
  End If
  Return dstProducts
End Function

The GetCachedProducts Web method caches the products database table in memory so that the database is not hit each and every time the Web method is called. Notice that you must refer to the Cache object within a Web method by using Context.Cache.

When you add a reference to a standard class library to a project, you only need to add a single reference. You don’t need to add a reference for each and every class contained in the library.

When adding a reference to a Web service, on the other hand, we’ve had to add a separate reference for each Web service. This is true even though all the Web services are collected together in the same project.

We’ve been adding references to Web services by referring to the WSDL file for a Web service. There’s an alternative. Instead of adding a reference to a WSDL file, you can add a reference to a .vsdisco file.

Whenever you create a new project in Visual Studio .NET, a .vsdisco file is automatically added to your project. The .vsdisco file is the dynamic discovery file. When you request a project’s dynamic discovery file, the ASP.NET Framework automatically searches for all the Web services contained in the project and displays them. If you enter the path to a project .vsdisco file when adding a Web reference, you get a proxy class that represents all the Web services in a project.

For security reasons, dynamic discovery is disabled by default. You can enable dynamic discovery by editing the Machine.Config file located in the WINNITMicrosoft.NETFrameworkFramework VersionConfig folder.

Open the Machine.Config file in Notepad, find the <httpHandlers> section, and remove the comments around the .vsdisco handler.

If you don’t want to modify the Machine.Config file (or you don’t have access to this file), you can also enable dynamic discovery for a ASP.NET Web Service project by adding the following section to the <system.web> section of the project root Web.Config file:

<httpHandlers>
  <add verb="*" path="*.vsdisco"
    type="System.Web.Services.Discovery.DiscoveryRequestHandler, System.Web.Services,
 Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" validate="false"/>
</httpHandlers>

After you complete these steps to enable dynamic discovery, you can replace all the individual Web references that you previously added with a single Web reference. Right-click the References folder and select Add Web Reference. In the address bar of the Add Web Reference dialog box, enter the path to the dynamic discovery file:

http://localhost/myServices/myServices.vsdisco

After you click Add Reference, you’ll have a single reference for all the Web services in the myServices project.

For example, to invoke the AddNumbers() method of the Math Service from a Web Form Page, you would use code like the following:

C#. 

localhost.MathServiceSoap objService =
    new localhost.MathServiceSoap();
Label1.Text = objService.AddNumbers(1,2).ToString();

VB.NET. 

Dim objService As New localhost.MathServiceSoap()
Label1.Text = objService.AddNumbers(1, 2)

Notice that you refer to the Math Service as MathServiceSoap instead of MathService. The expression Soap is automatically appended to the name of each of the Web service proxy classes when the Web reference is generated.