Windows Communication Foundation (WCF)

Windows Communication Foundation (WCF) is a dedicated communication frame work provided by the Microsoft. WCF is a part of .NET 3.0. The runtime environment provided by the WCF enables us to expose our CLR types as services and to consume other existing services as CLR types.

Background:

In the world there are lot of distributed communication technologies exist. Some of them are:

• ASP.NET Web Services (ASMX)
• Web Services Enhancements (WSE)
• Messaging (MSMQ)
• .NET Enterprise Services (ES)
• .NET Remoting

Creating and Consuming a Sample WCF Service:

Three major steps are involved while creating and consuming the WCF services. Those are:

1. Create the Service.(Creating)
2. Binding an address to the service and host the Service. (Hosting)
3. Consuming the Service.(Consuming)

Step 1: Creating the Service

In WCF, all services are exposed as contracts. Contract is a neutral way of describing the service what it does. Mainly we have four types of contracts:

1. Service Contract
   
   This contract describes all the available operations that client can perform on the service.
   
   .Net uses "System.ServiceModel" Name space to work with WCF services.
   
   ServiceContract attribute is used to define the service contract. We can apply this attribute on class or interface. Servicecontract attribute exposes a CLR interface (or a class) as a WCF contract.
   
   OperationContract attribute, is used to indicate explicitly which method is used to expose as part of WCF contract. We can apply OperationContract attribute only on methods, not on properties or indexers.  
   
   [ServiceContract] applies at the class or interface level.
   [OperatiContract] applies at the method level. 
   
   
2. Data Contract
   
   This contract defines the data types that passed in and out to the service.
   
   [DataContract] attribute is used at the custom data type definition level, i.e. at class or structure level.
   [DataMember] attribute is used to fields, properties, and events.
   
   
3. Fault Contract
   
   This contract describes about the error raised by the services. 
   
   [FaultContract(<<type of Exception/Fault>>)] attribute is used for defining the fault contracts.
   
   
4. Message Contracts
   
   This contract provides the direct control over the SOAP message structure. This is useful in inter operability cases and when there is an existing message format you have to comply with.
   
   [MessageContract] attribute is used to define a type as a Message type. 
   [MessageHeader] attribute is used to those members of the type we want to make into SOAP headers
   [MessageBodyMember] attribute is used to those members we want to make into parts of the SOAP body of the message. 

Sample Service Creation :

[ServiceContract]

          public interface IFirstWCFService

                    {

                   [OperationContract]

                   int Add(int x, int y);

                   [OperationContract]

                   string Hello(string strName);

                  int Multiplication(int x, int y);

                   }

Here "IFirstWCFService" is a service exposed by using the servicecontract attribute. This service exposes two methods "Add","Hello" by using the [OperationContract] attribute. The method "Multiplication" is not exposed by using the [OperationContract] attribute. So it wnt be avlible in the WCF service.

public class FrtWCFService : IFirstWCFService

    {

        public int Add(int x, int y)

        {

            return x + y;

        }

        public string Hello(string strName)

        {

            return "WCF program  : " + strName;

        }

        public int Multiplication(int x, int y)

        {

            return x * y;

        }

    }

"FrtWCFService" is a class,which implements the interface "IFirstWCFService". This class definse the functionality of methods exposed as services. 

STEP 2:  Binding and Hosting

Each service has an end point. Clients communicates with this end points only. End point describes 3 things :

1. Address
2. Binding type
3. Contract Name (which was defined in STEP 1)

Address

Every service must be associated with a unique address. Address mainly contains the following  two key factors :

1. Transport protocal used to communicate between the client proxy and service.
   
   WCF supports the following transport machinisams:
   
   
   • HTTP   (ex : http://  or https:// )
   • TCP     (ex :  net.tcp :// )
   • Peer network   (ex: net.p2p://)
   • IPC (Inter-Process Communication over named pipes) (ex: net.pipe://)
   • MSMQ  (ex: net.msmq://)
     
     

2. Location of the service.
   
   Location of the service describes the targeted machine(where service is hosted) complete name (or) path  and optionally port / pipe /queue name. 

   Example :   localhost:8081 
   Here local host is the target machine name.
   8081 is the optional port number. 

   Example 2:  localchost
   This is with out optional parameter. 

Here are a few sample addresses:  

http://localhost:8001

http://localhost:8001/MyFirstService

net.tcp://localhost:8002/MyFirstService

net.pipe://localhost/MyFirstPipe

net.msmq://localhost/MyFirstService

net.msmq://localhost/MyFirstService

Binding is nothing but a set of choices regarding the  transport protocol (which transport protocal we have to use : http /tcp /pipe etc.) ,message encoding (tells about the message encdong / decoidng technique)  ,communication pattern (whether communication is asynchronous, synchronous,  message queued etc.) , reliability, security, transaction propagation, and interoperability.

WCF defines the nine basic bindings:

Hosting:

Every service must be hosted in a host process. Hosting can be done by using the

• IIS
• Windows Activation Service (WAS)
• Self hosting
   

IIS Hosting

IIS hosting is same as hosting the traditional web service hosting. Create a virtual directory and supply a .svc file.

In Vs2008 select a project type: "WCF Service Application".

In the solution explorer, under the App_code folder you can find the two files: "IService.cs" and "Service.cs".

"IService.cs" class file defines the contracts. "Service.cs" implements the contracts defined in the "IService.cs". Contracts defined in the "IService.cs" are exposed in the service. 

Check in the Web.Config file, under <system.serviceModel> section:

In this one , end point node specifies the : address, binding type, contract (this is the name of the class that defines the contracts.)

Another end point node endpoint address="mex" specify about the Metadata end point for the service.

Now host this serivce by creating the virtual directory and browse the *.SVC file:

Hosting with Windows Activation Service (WAS)

WAS is a part of IIS 7.0. It comes with VISTA OS. The hosting with the Windows Activation Service is same as hosting with IIS. The only difference between these two is, IIS supports for HTTP binding only. Whereas WAS supports for all transport schemas.

Self Hosting

In this technique developer is only responsible for providing and managing the life cycle of the host process. In this one host service must be running before the client calls the service.  To host the service we use the .NET class ServiceHost.  We have to create an instance of the "ServiceHost".  Constructor of this class takes two parameters: service type, base address. (Base address can be empty set.)

ServiceHost srvHost = new
ServiceHost(typeof(WCFService.FrtWCFService),baseaddress);

Add the Service End points to the host :

We will use the AddServiceEndpoint() to add an end point to the host. As we awre that end point contains thress things:  type of service, type of binding, service Name.

So, AddServiceEndpoint() method accepts these three as the required parameters.

srvHost.AddServiceEndpoint(typeof(WCFService.IFirstWCFService), new BasicHttpBinding(), "FirstWCFService");

Adding the Meta Data End points to the host:

For the Meta data, service type will be: typeof(IMetadataExchange)

srvHost.AddServiceEndpoint(typeof(IMetadataExchange), httpBinding, "MEX");

Up to Now, we have created the host process and add the end points to it. Now call the open() method on the host. By calling the Open( ) method on the host, we allow calls in, and by calling the Close( ) method, we stylishly exit the host instance, that means, allowing calls in progress to complete, and yet refusing future new client calls even if the host process is still running

srvHost.Open();

STEP 3: Consuming the Service

With WCF, the client always communicates with the proxy only. Client never directly communicates with the services, even though the service is located on the same machine. Client communicates with the proxy; proxy forwards the call to the service.  Proxy exposes the same functionalities as Service exposed.

Consuming WCF Service Hosted by IIS/WAS

Consuming WCF service is very similar way of consuming a web service by using the proxy. To consume the service, in the solution explorer click on "Add service Reference" and add the service created in the STEP1.

A service reference is created under the service reference folder. Use this proxy class to consume the WCF service as we are doing with web services.

ServiceReference1.FirstWCFServiceClient obj = new                 

             UsingWCFService.ServiceReference1.FirstWCFServiceClient();

Console.WriteLine(obj.Add(2, 3).ToString());

obj.Close();

Alternatively: We can create  the proxy class by using the following command

svcutil.exe [WCFService Address]

This generates a service proxy class, just include this class in to the solution and consume the service.

Consuming by creating the channel factory:

We can consume the service by creating the channel factory manually. While creating the channel, we have to provide the same binding type and end point address where the service is hosted.

IFirstWCFService chnl = new ChannelFactory<IFirstWCFService>

(new BasicHttpBinding(), new EndpointAddress("http://localhost:8080/MYFirstWCFService")).CreateChannel();

Here IFirstWCFService is the service contract interface, that is exposed.