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
ExistingTechnologies.gif

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
  1. [ServiceContract]
  2. public interface IFirstWCFService
  3. {
  4. [OperationContract]
  5. int Add(int x, int y);
  6. [OperationContract]
  7. string Hello(string strName);
  8. int Multiplication(int x, int y);
  9. }
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.
  1. public class FrtWCFService: IFirstWCFService
  2. {
  3. public int Add(int x, int y)
  4. {
  5. return x + y;
  6. }
  7. public string Hello(string strName)
  8. {
  9. return "WCF program : " + strName;
  10. }
  11. public int Multiplication(int x, int y)
  12. {
  13. return x * y;
  14. }
  15. }
"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)
Endpoints.GIF
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".
ProjectType.GIF
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:
  1. <services>
  2. <service name="Service" behaviorConfiguration="ServiceBehavior">
  3. <!-- Service Endpoints -->
  4. <endpoint address="" binding="wsHttpBinding" contract="IService">
  5. <!--
  6. Upon deployment, the following identity element should be removed or replaced to reflect the
  7. identity under which the deployed service runs. If removed, WCF will infer an appropriate identity
  8. automatically.
  9. -->
  10. <identity>
  11. <dns value="localhost"/>
  12. </identity>
  13. </endpoint>
  14. <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
  15. </service>
  16. </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:
IISHosting.GIF

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.)
  1. Uri baseaddress = new Uri("http://localhost:8080");
  3. ServiceHost srvHost = new
  4. 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.
  1. 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)
  1. 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
  1. 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.
ServiceBoundaries.GIF

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.
AddServiceRef.GIF
AddServiceRef_2.GIF
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.
  1. ServiceReference1.FirstWCFServiceClient obj = new
  2. UsingWCFService.ServiceReference1.FirstWCFServiceClient();
  3. Console.WriteLine(obj.Add(2, 3).ToString());
  4. 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.
  1. IFirstWCFService chnl = new ChannelFactory<IFirstWCFService>
  3. (new BasicHttpBinding(), new EndpointAddress("http://localhost:8080/MYFirstWCFService")).CreateChannel();
Here IFirstWCFService is the service contract interface, that is exposed.