Windows Communication Foundation (WCF)

Windows Communication Foundation (WCF) is a dedicated communication framework provided by 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.


In the world there are a lot of distributed communication technologies that 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 in the creation and consumtion of 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)
  4. Step 1: Creating the Service


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


  1. Service Contract : This contract describes all the available operations that a 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 are passed into and out of the service.[DataContract] attribute is used at the custom data type definition level, i.e. at class or structure level. 


    [DataMember] attribute is used for 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 for those members of the type we want to make into SOAP headers
    [MessageBodyMember] attribute is used for those members we want to make into parts of the SOAP body of the message.

  5. Sample Service Creation :


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.

“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)

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:  localhost
    This is with out optional parameter.

Here are a few sample addresses:


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

Hosting Type Advantages Limitations
IIS Hosting IIS manages the life cycle of host process. ( like application pooling, recycling, idle time management, identity management, and isolation) Only HTTP transport schemas WCF service are hosted in IIS.
WAS Hosting
  • WAS supports for all available WCF transports, ports, and queues.
  • WAS manages the life cycle of host process.
Some adv of self hosted processing is missing.
Self Hosting
  • Developer can have explicit control over opening and closing the host.
  • In-Proc hosting can be done.
Missing the host process life cycle management.

IIS Hosting

IIS hosting is the 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:

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.)

Uri baseaddress = new Uri(“http://localhost:8080&#8221;);

ServiceHost srvHost = new

Add the Service End points to the host :

We will use the AddServiceEndpoint() to add an end point to the host. As we are that end point contains three 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 added 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


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 a 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.