WCF Programming for Beginners

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.

 

Background

 

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 consumption of 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. 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" Namespace 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 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 direct control over the SOAP message structure. This is useful in interoperability 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. 

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 endpoint. Clients communicate with this endpoints only. Endpoint 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 protocol 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 localhost is the target machine name.
   8081 is the optional port number. 
   Example 2:  localhost
   This is without 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 protocol we have to use: http /tcp /pipe etc.) ,message encoding (tells about the message encoding / decoding technique)  ,communication pattern (whether communication is asynchronous, synchronous,  message queued etc.) , reliability, security, transaction propagation, and interoperability. 

 

WCF defines the nine basic bindings:

Binding Type	.Net Class implements this binding	Transport	Encoding	Interoperable	Comments
Basic Binding	BasicHttpBinding	Http / Https	Text / MTOM	Yes	Used to expose a WCF service as a legacy ASMX web service.
TCP binding	NetTcpBinding	TCP	Binary	NO	TCP is used for cross-machine communication on the intranet.
Peer network binding	NetPeerTcpBinding	P2P	Binary	NO	In this peer network transport schema is used to communicate.
IPC binding	NetNamedPipeBinding	IPC	Binary	NO	This uses named pipes as a transport for same-machine communication. It is the most secure binding since it cannot accept calls from outside the machine.
WSbinding	WSHttpBinding	Http / Https	Text / MTOM	Yes	This uses Http / Https as a communication schema.
Federated WS binding	WSFederationHttpBinding	Http / Https	Text / MTOM	Yes	This is a specialization of the WS binding. This offers the support for federated security
Duplex WS binding	WSDualHttpBinding	Http	Text / MTOM	Yes	This is a WS binding with bidirectional communication support from the service to the client.
MSMQ binding	NetMsmqBinding	MSMQ	Binary	NO	This supports for disconnected queued calls
MSMQ integration binding	MsmqIntegrationBinding	MSMQ	Binary	Yes	This is designed to interoperate with legacy MSMQ clients.

Hosting

 

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

• 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 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:

<services>
      <service name="Service" behaviorConfiguration="ServiceBehavior">
        <!-- Service Endpoints -->
        <endpoint address="" binding="wsHttpBinding" contract="IService">
          <!--
          Upon deployment, the following identity element should be removed or replaced to reflect the
              identity under which the deployed service runs.  If removed, WCF will infer an appropriate identity
              automatically.
          -->
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
</services>

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 service 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, the 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");

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

Add the Service Endpoints to the host

 

We will use the AddServiceEndpoint() to add an endpoint 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 Endpoints 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 endpoints 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 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.

 

 

 

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 into 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 endpoint 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.