Web Services in C#

<%@ WebService Language="C#" CodeBehind="Service1.asmx.cs" Class="MyWebServiceDemo.Service1"%> 

<%@ WebService Language="C#" CodeBehind="MyService.asmx.cs" Class="MyWebServiceDemo.MyService"%>

using System.Web.Script.Serialization;  
using System.Web.Services;  
  
namespace MyWebServiceDemo  
{  
    // Use "Namespace" attribute with an unique name,to make service uniquely discoverable  
    [WebService(Namespace = "http://tempuri.org/")]  
    // To indicate service confirms to "WsiProfiles.BasicProfile1_1" standard,   
    // if not, it will throw compile time error.  
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]  
    // To restrict this service from getting added as a custom tool to toolbox  
    [System.ComponentModel.ToolboxItem(false)]  
    // To allow this Web Service to be called from script, using ASP.NET AJAX  
    [System.Web.Script.Services.ScriptService]  
    public class MyService : WebService  
    {  
        [WebMethod]  
        public int SumOfNums(int First, int Second)  
        {  
            return First + Second;  
        }  
    }  
}

[WebMethod]  
public float SumOfNums(float First, float Second)  
{  
    return First + Second;  
}

[WebMethod (MessageName = "SumOfFloats")]  
public float SumOfNums(float First, float Second)  
{  
    return First + Second;  
}

using System.Web.Script.Serialization;  
using System.Web.Services;  
  
namespace MyWebServiceDemo  
{  
    [WebService(Namespace = "http://tempuri.org/")]  
    [WebServiceBinding(ConformsTo = WsiProfiles.None)]  
    [System.ComponentModel.ToolboxItem(false)]  
    [System.Web.Script.Services.ScriptService]  
    public class MyService : WebService  
    {  
        [WebMethod]  
        public int SumOfNums(int First, int Second)  
        {  
            return First + Second;  
        }  
        [WebMethod(MessageName = "SumOfFloats")]  
        public float SumOfNums(float First, float Second)  
        {  
            return First + Second;  
        }  
    }  
}

Now, the question is, from where does this test page come? We never added any mark up but still a page was rendered!

The test pages aren't part of the Web Services; they're just a frill provided by ASP.NET. The test page is rendered by ASP.NET using the web page c:\[WinDir]\Microsoft. NET\Framework\[Version] \Config\DefaultWsdlHelpGenerator.aspx. “Reflection” concept to render the test page.

You can also modify this test page for which you simply need to copy the DefaultWsdlHelpGenerator.aspx file to your web application directory, modify it and give it a name. I named it “MyWsdlHelpGenerator.aspx” and then changed the web.config file for the application by adding the <wsdlHelpGenerator> element, as shown here:

<configuration>  
    <system.web>  
        <webServices>  
            <wsdlHelpGenerator href="MyWsdlHelpGenerator.aspx"/>  
        </webServices>  
    </system.web>  
</configuration> 

The WSDL document

Web Services are self-describing, that means ASP.NET automatically provides all the information the client needs to consume a service as a WSDL document. The WSDL document tells a client what methods are present in a web service, what parameters and return values each method uses and how to communicate with them. WSDL is a XML standard. We'll explore the WSDL document in our next articles.

Host a web service

Since we will add a reference to this service and consume it from various applications and the port number is supposed to change, let's host this service on IIS to have a specific address of a service. Open IIS, go to the default web sites node then seelct Add Application then provide an alias name (I gave it WebServiceForBlog) then browse to the physical location of your service for the physical path field then click “OK”. You can now browse with an alias name (like http://localhost/WebServiceForBlog/) to test if the application was hosted properly. You'll get a “HTTP Error 403.14 – Forbidden” error since there is no default document set for this application. Add a “MyService.asmx” page as a default document. Now you can browse your service.

How to access a web service from a client application

Here our primary focus will be on consuming a web service. Let's quickly create a web service (or modify, if you have already created one).

MyService.asmx

<%@ WebService Language="C#" CodeBehind="MyService.asmx.cs" Class="MyWebServiceDemo.MyService" %>

MyService.asmx.cs

using System.Web.Script.Serialization;  
using System.Web.Services;  
  
namespace MyWebServiceDemo  
{  
    [WebService(Namespace = "http://tempuri.org/")]  
    [WebServiceBinding(ConformsTo = WsiProfiles.None)]  
    [System.ComponentModel.ToolboxItem(false)]  
    [System.Web.Script.Services.ScriptService]  
    public class MyService  
    {  
        // Takes 2 int values & returns their summation  
        [WebMethod]  
        public int SumOfNums(int First, int Second)  
        {  
            return First + Second;  
        }  
  
        // Takes a stringified JSON object & returns an object of SumClass  
        [WebMethod(MessageName = "GetSumThroughObject")]  
        public SumClass SumOfNums(string JsonStr)  
        {  
            var ObjSerializer = new JavaScriptSerializer();  
            var ObjSumClass = ObjSerializer.Deserialize<SumClass>(JsonStr);  
            return new SumClass().GetSumClass(ObjSumClass.First, ObjSumClass.Second);  
        }  
    }  
  
     // Normal class, an instance of which will be returned by service  
    public class SumClass  
    {  
        public int First, Second, Sum;  
  
        public SumClass GetSumClass(int Num1, int Num2)  
        {  
            var ObjSum = new SumClass  
            {  
                Sum = Num1 + Num2,  
            };  
            return ObjSum;  
        }  
    }  
}

Compile this application. Since we will consume this service from other applications we need a fixed address for this service, the port numbers are supposed to vary. So, host the web service on IIS (refer to the previous article for hosting the web service). I hosted it with the virtual directory “WebServiceForBlog”.

How to consume a web service

Let's add another project to our solution. You can also create a new project. I am adding to the same solution, so that it will not need me to open several instances of Visual Studio. When developing and testing a web service in Visual Studio, it's often preferred to add both the web service and the client application to the same solution. This allows you to test and change both pieces at the same time. You can even use the integrated debugger to set breakpoints and step through the code in both the client and the server.

Right-click on solution, select Add → New project then seelct ASP.NET Empty Application then name your application, I am naming it “ServiceConsumer”.

Add a Web Form, I name it “Home.aspx”.

On the click of a button in this page, we will call our service.

For calling a Web Service you need a proxy object that will handle the complexities of sending a SOAP request and response messages.

To create this proxy class, you need a reference to the service class. Right-click on this project then select Add service reference, a window will open, type the URL of your service, click on discover, you will see all the webmethods exposed by your service listed. At the bottom of the window, there'll be a field for Namespace. Provide a name for the namespace in which the proxy class of the referenced service will be generated, I am giving it “MyServiceReference”. Now, click on “Go”.

By adding a service reference, we created a proxy class of the referenced service to the current project (client app).

The proxy class wraps the calls to the web service's methods. It takes care of generating the correct SOAP message format and managing the transmission of the messages over the network using HTTP and converting the results received back to the corresponding .NET data types.

Now, add mark up in Home.aspx to receive inputs. Here's my mark up.

<table>  
    <tr>  
        <td>First Number:</td>  
        <td><input type="text" id="Text1" runat="server" /></td>  
    </tr>  
    <tr>  
        <td>Second Number:</td>  
        <td><input type="text" id="Text2" runat="server" /></td>  
    </tr>  
    <tr>  
        <td><input type="button" onserverclick="AddNumber" value="Add" runat="server" /></td>  
        <td><div id="divSum" runat="server"></div>  
        <div id="divSumThroughJson" runat="server"></div></td>  
    </tr>  
</table>

Home.aspx.cs

using System;  
using ServiceConsumer.MyServiceReference;  
  
namespace ServiceConsumer  
{  
    public partial class Home : System.Web.UI.Page  
    {  
        protected void Page_Load(object sender, EventArgs e)  
        {}  
        protected void AddNumber(object Sender, EventArgs E)  
        {  
            int Num1, Num2;  
            int.TryParse(txtFirstNum.Value, out Num1);  
            int.TryParse(txtSecondNum.Value, out Num2);  
            // creating object of MyService proxy class  
            var ObjMyService = new MyServiceSoapClient();  
  
            // Invoke service method through service proxy  
            divSum.InnerHtml = ObjMyService.SumOfNums(Num1, Num2).ToString();  
  
            var ObjSumClass = new SumClass { First = Num1, Second = Num2 };  
            var ObjSerializer = new JavaScriptSerializer();  
            var JsonStr = ObjSerializer.Serialize(ObjSumClass);  
            divSumThroughJson.InnerHtml =ObjMyServiceProxy.GetSumThroughObject(JsonStr).Sum.ToString();  
        }  
    }  
}

How to consume a web service from a client script

Add another project to your solution. I named it “ConsumeServiceFromClientScript”. Add a web form (let's say Default.aspx).

Creating a JavaScript proxy

JavaScript proxies can be automatically generated by using the ASP.NET AJAX ScriptManager control's Services property. You can define one or more services that a page can call asynchronously to send or receive data using the ASP.NET AJAX “ServiceReference” control and assigning the Web Service URL to the control's “Path” property.

Add a ScriptManager control like the following inside the form tag:

<asp:ScriptManager runat="server">  
     <Services>  
          <asp:ServiceReference Path="http://localhost/WebServiceForBlog/MyService.asmx"/>  
      </Services>  
</asp:ScriptManager>

When you add a reference to a web service (MyService.asmx) from a page using a ScriptManager control, a JavaScript proxy is generated dynamically and referenced by the page. Now if you the check page source in a browser, you can notice that:

http://localhost/MyWebServiceDemoService/MyService.asmx/js

Or:

http://localhost/MyWebServiceDemoService/MyService.asmx/jsdebug

Is included in your page with a script tag depending on whether debugging is enabled In your project.

Add an empty Web form to your project. I named it “Default.aspx”.

Default.aspx

<body>  
    <form id="form1" runat="server">  
       <asp:ScriptManager runat="server">  
            <Services>  
                <asp:ServiceReference Path="http://localhost/WebServiceForBlog/MyService.asmx"/>  
            </Services>  
        </asp:ScriptManager>  
        <div>  
            <table>  
                <tr>  
                    <td>First Number:</td>  
                    <td><input type="text" id="txtFirstNum" /></td>  
                </tr>  
                <tr>  
                    <td>Second Number:</td>  
                    <td><input type="text" id="txtSecondNum" /></td>  
                </tr>  
                <tr>  
                    <td><input type="button" onclick="AddNumber();" value="Add" /></td>  
                    <td><div id="divSum1"></div><div id="divSum2"></div><div id="divSum3"></div><div id="divSum4"></div><div id="divSum5"></div></td>  
                </tr>  
            </table>  
        </div>  
    </form>  
    <script type="text/javascript" src="Scripts/jquery-1.7.1.js"></script>  
    <script type="text/javascript" src="Scripts/json2.js"></script>  
    <script type="text/javascript">  
        function AddNumber() {  
            var FirstNum = $('#txtFirstNum').val();  
            var SecondNum = $('#txtSecondNum').val();  
  
            $.ajax({  
                type: "POST",  
                url: "http://localhost/WebServiceForBlog/MyService.asmx/SumOfNums",  
                data: "First=" + FirstNum + "&Second=" + SecondNum,   
          // the data in form-encoded format, it would appear on a querystring  
               //contentType: "application/x-www-form-urlencoded; //charset=UTF-8"
               //form  encoding is the default one  
                dataType: "text",  
                crossDomain: true,  
                success: function (data) {  
                    $('#divSum1').html(data);  
                }  
            });  
  
            // i/p in JSON format, response as JSON object  
            $.ajax({  
                type: "POST",  
                url: "http://localhost/WebServiceForBlog/MyService.asmx/SumOfNums",  
                data: "{First:" + FirstNum + ",Second:" + SecondNum + "}",  
                contentType:"application/json; charset=utf-8",// What I am ing  
                dataType: "json", // What I am expecting  
                crossDomain: true,  
                success: function (data) {  
                    $('#divSum2').html(data.d);  
                }  
            });            
  
        // i/p as JSON object, response as plain text  
            $.ajax({  
                type: "POST",  
                url: "http://localhost/WebServiceForBlog/MyService.asmx/SumOfNums",  
                data: { First: FirstNum, Second: SecondNum },  
                contentType: "application/x-www-form-urlencoded; charset=UTF-8",  
                crossDomain: true,  
                dataType: "text",  
                success: function (data) {  
                    $("#divSum3").html(data);  
                }  
            });  
  
        // Url encoded stringified JSON object as I/p & text response  
            var ObjSum = new Object();  
            ObjSum.First = FirstNum;  
            ObjSum.Second = SecondNum;  
            $.ajax({  
                type: "POST",  
                url: "http://localhost/WebServiceForBlog/MyService.asmx/GetSumThroughObject",  
                data: "JsonStr=" + JSON.stringify(ObjSum),  
                dataType: "text",  
                crossDomain: true,  
                success: function (data) {  
                    $('#divSum4').html($(data).find('Sum').text());  
                }  
            });  
  
            // Call SOAP-XML web services directly   
            var SoapMessage = '<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"> \  
                                      <soap:Body> \  
                                        <SumOfNums xmlns="http://tempuri.org/"> \  
                                          <First>'+FirstNum+'</First> \  
                                          <Second>'+SecondNum+'</Second> \  
                                        </SumOfNums> \  
                                      </soap:Body> \  
                                    </soap:Envelope>';  
            $.ajax({  
                url: "http://localhost/WebServiceForBlog/MyService.asmx?op=SumOfNums",  
                type: "POST",  
                dataType: "xml",  
                data: SoapMessage,  
                complete: ShowResult,  
                contentType: "text/xml; charset=utf-8"  
            });  
        }  
        function ShowResult(xmlHttpRequest, status) {  
            var SoapResponse = $(xmlHttpRequest.responseXML).find('SumOfNumsResult').text();  
            $('#divSum5').html(SoapResponse);  
        }  
    </script>  
</body>

Note: For demo purposes, I have hard-coded the service URL. But it's not a good practice. You can keep the service URL in the web.config and use RegisterClientScriptBlock or RegisterStartUpScript depending on your requirements to use this service URL in client script.

Call SOAP-XML Web Services directly

In order to call the web service, we need to supply an XML message that matches the operation definition specified by the web service's WSDL. In the test page “http://localhost/WebServiceForBlog/MyService.asmx?op=SumOfNums” you can see a sample of SOAP 1.1/1.2 request and response format. From which you can get the operations schema. Now, you just need to exchange the type names for the operation's parameters, with their actual values. Copy the SOAP envelope to the Default.aspx page and replace the place holders (type names) with an actual value.

A sample for this type of call is included in the code snippet above. The variable “SoapMessage” in the preceding example contains the complete XML message that we're going to send to the web service. On completion of the ajax request, we will call a call back method named “ShowResult”.

Note: .NET 1.x supports SOAP 1.1 only. From .NET 2.0 Both SOAP1.1 and SOAP1.2 are supported unless one is restricted explicitly. If you want to change this, you can disable either one through the web.config file:

<configuration>  
      <system.web>  
    <webServices>  
           <protocols>  
           <!-- To disable SOAP 1.2 -->  
           <remove name="HttpSoap12"/>  
           <!-- To disable SOAP 1.1 -->  
           <remove name="HttpSoap"/>  
           </protocols>  
    </webServices>  
       </system.web>  
</configuration> 

References

Book: Programming .NET Web Services By Alex Ferrara, Matthew MacDonald
Book: Pro ASP.NET 3.5 in C# by Matthew MacDonald , Mario Szpuszta
Understanding ASP.NET AJAX Web Services