You are on page 1of 7

Understanding the Basics of

Web Service in ASP.NET


Rahul Rajat Singh,
Introduction
This article aims at understanding the need for a web service, the benefits of having a web service
and how we can create a basic web service and consume it.

Background
Connectivity between applications is very important. Connectivity in any case is very important
for that matter but it specially is very important between applications. Connecting web
application used to be a big challenge before the advent of technologies like SOAP (Simple
Object Access Protocol). The reason it was so difficult was, there were so many technologies
people were working in. The applications were hosted on different types of servers, etc. But these
things should not be a barrier to facilitate the communication between applications. The only
requirement was to have some standards to follow and standard ways of doing things so that the
applications become capable of communicating with other applications irrespective of the
technologies used.

SOAP and Web Services


SOAP and XML created the solution for the problem that developers were facing before. SOAP is
a standard XML based protocol that communicated over HTTP. We can think of SOAP as
message format for sending messaged between applications using XML. It is independent of
technology, platform and is extensible too.

We have SOAP and XML to give us connectivity between applications. Does it mean that I have to
write XML and SOAP specific things myself to facilitate this communications? I could do that but
that will be very time consuming and sometimes error prone too.

Where does Web Services come in picture? Well, Web services is the mechanism that ASP.NET
framework provides to make it easy for us to write code to facilitate connectivity between
applications. As ASP.NET developer, If I need an application that will be used by many other
applications then I can simply decide to write a web service for it and ASP.NET framework will
take care of doing the low level SOAP and XML work for us.

The other side of the coin is, if our ASP.NET application wants to use a web service, i.e., an
application that is providing me SOAP based interface for communication. So what we are going
to do now is write a small Web service to see how we can have our application communication-
ready for other applications and secondly, we will try to consume a webservice to understand
how we can use other applications from our application.
Creating a Web Service
Let us write a simple module that will provide basic arithmetic operations to other applications.
The user of our application will have to provide us 2 numbers and we will perform the requested
operation like Addition, Subtraction and Multiplication.

So, the first thing we need to do is to create our web service. We can do this by creating a
website of type ASP.NET Web service. This will give us a skeleton to write our web service code in.

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
public Service () {

//Uncomment the following line if using designed components


//InitializeComponent();
}

[WebMethod]
public string HelloWorld() {
return "Hello World";
}
}

The attribute WebService tells that this class contains the code for web service. The namespace
is what is used to identify the web service. The WebMethodattribute specifies the methods which
our web service is providing.

Let us now go ahead and write code to have our functions in this webservice.

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
public Service ()
{
//Uncomment the following line if using designed components
//InitializeComponent();
}

[WebMethod]
public int Add(int x, int y)
{
return x+y;
}

[WebMethod]
public int Subtract(int x, int y)
{
return x - y;
}

[WebMethod]
public int Multiply(int x, int y)
{
return x * y;
}
}

We have a very basic web service implemented which can let the user have some basic arithmetic
operations. Now to create the WebService binary, we will have to use the following command
on Visual Studio Command Prompt.

>CSC /t:library /out:ArithmeticServiceImpl.dll App_code\Service.cs

This will create a DLL file for our web service. This DLL file can be used by any client by using the
SOAP protocol. If we need to test our web service for how it works over the SOAP protocol, we
can view the service.asmx file in the browser and see what functions our web service is exposing.

We can even test these methods here and see the XML file that contains the service description.

Consuming a WebService
There are three ways we can consume a WebService:

1. Using HTTP-POST method.


2. Using XMLHttp that will use SOAP to call our the service
3. Using WSDL generated proxy class

The HTTP-Post method can be used by calling .asmx file directly from client. We can directly use
the method name and the parameter names will be taken from our input fields on form.

<html>
<body>
<form action="http://localhost/.../Service.asmx/Multiply" method="POST">
<input name="x"></input>
<input name="y"></input>

<input type="submit" value="Enter"> </input>


</form>
</body>
</html>

When this form get submitted, the web service's method will be called. The second method
where we can use the XMLHttp over SOAP to access the webservice is used when we want to
use the web service using full capability of SOAP.

The third way of using the web service is by generating a Proxy class for the web service and
then using that proxy class. This method is, to me, more type safe and less error prone as once
we have the proxy class generated, it can take care of SOAP messages, serialization and ensure
that all the problems can be handled at compile time instead of runtime.

To use this service, we need to do "Add Web reference" and add the webservice reference.
Alternatively I can also use WSDL.exe, a command line tool, to generate the proxy classes and use
them. "Add web Reference" is also using the same WSDL.exe to generate the proxy classes.
Now let us write some code to use the proxy class to perform the operations, the proxy class will
then communicate to the web service using SOAP and get back the results to us.

protected void Button1_Click(object sender, EventArgs e)


{
if (txtX.Text != string.Empty
&& txtY.Text != string.Empty)
{
try
{
int x = Convert.ToInt32(txtX.Text);
int y = Convert.ToInt32(txtY.Text);

ArithmeticService.Service service = new ArithmeticService.Service();

Label1.Text = "Sum: " + service.Add(x, y).ToString();


Label2.Text = "Difference: " + service.Subtract(x, y).ToString();
Label3.Text = "Multiplication: " + service.Multiply(x, y).ToString();
}
catch(Exception)
{
throw;
}
}
}

Let us run the website to see the results


Points of Interest
We saw how to create a web service in ASP.NET and how we can consume a web service in
ASP.NET. One interesting area that we did not see here is how we can use web service from AJAX.
ASP.NET also provides a mechanism using scriptManager that will generate the JavaScript
proxy for a webservice and we can use it to call the webservice methods. Also, if we want to
customize the security of our web service, we can do that too using custom SOAP headers.

You might also like