.NET Web Services

There are some key protocol flows that make a complete web services as in the following:

• SOAP (Simple Object Access Protocol)
• DISCO (discovery)
• UDDI (Universal Description, Discovery and Integration)
• WSDL (Web Services Description Language)

SOAP

Web Services manipulate objects through a XML message. SOAP enables you to expose and consume complex data structures that includes items such as data sets and tables. The Data Sets you send or consume can flow over the same internet wire (HTTP), thereby passing through firewalls. SOAP defines the message you use to exchange the data but it doesn't describe how you send the message. In other words, to communicate with web services a client opens an HTTP connection and sends a SOAP message. SOAP is XML based; it can be interpreted by a wide range of software on many operating systems.

SOAP Request

Here a typical SOAP message sent from a Web Service client to a server as in the following:

POST /TestWS/UtilityWebService.asmx HTTP/1.1
Host: localhost
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length

<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
  <soap12:Body>
    <addition xmlns="http://tempuri.org/">
      <a>int</a>
      <b>int</b>
    </addition>
  </soap12:Body>
</soap12:Envelope>

SOAP Response

Here is a part of the SOAP message back from the server:

HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
 
<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
  <soap12:Body>
    <additionResponse xmlns="http://tempuri.org/">
      <additionResult>int</additionResult>
    </additionResponse>
  </soap12:Body>
</soap12:Envelope>

DISCO

Before you can use a Web service, you need to know where to find the Service. The DISCO standard creates a single file that is the repository of all related web services. You can publish a DISCO file on its server that contains links to all the web services it provides. Then the client simply needs to request this file to find all the available web services. When you set a Web Reference inside .NET, the software automatically handles the details of discovery for you. But you can also get into the details of the process yourself by using DISCO.exe as in the following:

disco http://localhost:2186/TestWS/WebService.asmx

This tool disco.exe contacts the web service and creates two additional files with .discomap and .wsdl extension. These files are XML files that will show you the name of other file and the URL.

UDDI

UDDI is a centralized directory where web services are published. This is where potential client can go to search for their specific needs. Each organization may use different UDDI registries. To retrieve information from a UDDI directory, you use a web service interface.

WSDL

Before consuming a web service, it is required to have the knowledge of a SOAP message that it can send and receive. WDSL is a standard by which a web service can tell clients what message it accepts and what results it will return. WSDL defines everything about the public interface of a web service such as data type, the methods it exposes and the URL through which those methods can be accessed.

Consuming Web Service

Before consuming a web service, we need to generate a Proxy class that wraps the call to the web services methods. It takes care of generating the correct SOAP message format and managing the transmission of the message over the wire using HTTP on port 80. When it gets the response message back, it also convert the results back to the corresponding .NET data types.

We can generate a Proxy class in .NET in either of the following two ways:

1. Visual Studio IDE web reference feature
2. Command line utility Wsdl.exe

Generating the Proxy class with VS IDE

1. Deign the default.aspx with two textboxes, three labels and a single button server control as in the following.
2. Right-click over the client project in the Solution Explorer, and select "Add Service reference", then click on the "Advanced" button in the dialog box and finally click "Add Web Reference" as in the following.
3. Copy the Web Service URL from the image 1.2, paste into the URL text box and hit Enter. This operation will browse your web service.
   
   
   Figure 1.5: Add Web Reference Dialog box
   
4. The web service test page will appear in the windows with an entire methods list and the "Add Reference" button will be enabled as:
   
   
   Figure 1.6: Adding a Web Reference
   
5. In the Web Reference name text box you can change the namespace in which the proxy class will generated.
6. Now click over the "Add Reference" button.
7. Now the web reference will appear in the Web References group for the project in the Solution Explorer window as in the following:
   
   
   Figure 1.7: Web Reference in Solution Explorer
   
8. Open the Default.aspx.cs file and add a button click handler and put the following code in it:

   public partial class_Default : System.Web.UI.Page
   {  
       protected void btnAdd_Click(object sender,EventArgs e)
       {
           int x, y, Result;
           x = Convert.ToInt32(TextBox1.Text);
           y = Convert.ToInt32(TextBox2.Text);
           //web service class instantiation
           localhost.UtilityWebService obj = new localhost.UtilityWebService();
   
           //Method call
           Result=obj.addition(x, y);
           //Output
           Label3.Text = Result.ToString(); 
       }
   }

9. Finally run the project and enter 2 integer type values in the given text boxes and hit the button for calling the additional web service method as in the following:
   
   
   
   Figure 1.8: Addition Web Reference Result

Generating the Proxy class WSDL.EXE

This utility takes a WSDL file and generates a corresponding proxy class that you can use to invoke the web service. This tool does not require the web service client to use the .NET IDE.

1. Open a command prompt from "Start" -> "All Programs" -> "Microsoft Visual Studio 10" -> "Visual Studio Tools".
2. Then navigate to the folder that contains the WSDL file and fire this command as.
   
   wsdl /out:UtilityWebServiceProxy.cs http://localhost:2186/TestWS/UtilityWebService.asmx
   
   By default the generated class is in the C# language, but you can change it by adding the /language:vb parameter.
3. If you browse to your project directory, notice that the "UtilityWebServiceProxy.cs" file is added there.
4. Now copy this file to your project's "App_Code" folder by selecting "Add Existing Item" from the Solution Explorer.
5. And finally instantiate the web service class again.
   
   Note: if the client is already consuming the web service and you make a change later in this then you don't need to perform the entire process again. Just go the Solution Explorer, right-click over the web reference folder and select update reference. All the new definitions are reflected automatically.

Refining Web Services

There are a couple of other features of web services. For instance, session state, data caching and transactions. The secret of applying these features is the WebMethod attribute. However several other WebMethod properties exist as described in the following table.

Arguments	Description
CacheDuration	This depicts the number of seconds that the method response will be maintained in cache.
Description	This elaborates the method description.
EnableSession	Configure the method to access information in the session collection.
TransactionOption	Get or Set the transaction type such as allowed,NotSupported,Required,Supported etc..
BufferResponse	It is true by default and determines whether the method response is buffered.

Cache duration

[WebMethod(CacheDuration=50)]
public int addition(int a, int b)
{
    ..
}

Description

[WebMethod(Description="Retrun the addition of two integer")]
public int addition(int a, int b)
{
    ..
}

Session

[WebMethod(EnableSession=true)]
public int addition(int a, int b)
{
    ..
}

Transaction Option

[WebMethod(TransactionOption=TransactionOption.RequiresNew)]
public int addition(int a, int b)
{
   ..
}

Buffer Response

[WebMethod(BufferResponse=false)]
public int addition(int a, int b)
{
   ..
}