wcf

WCF - Automatically create ServiceHost for multiple services

Rajesh Pillai — Thu, 24 Feb 2011 06:06:49 GMT

WCF - Automatically create ServiceHost for multiple services

Welcome back readers! This blog post is about a small tip that may make working with WCF servicehost a bit easier, if you have lots of services and you need to quickly host them for testing.
Recently I was encountered a situation where we were faced to create multiple service host quickly for testing. Here is the code snippet which is pretty self explanatory. You can put this code in your service host which in this case is a console application.

class Program
   {
       static void Main(string[] args)
       {                        
           // Stores all hosts
           List<ServiceHost> hosts = new List<ServiceHost>();

           try
           {                                   
               // Get the services element from the serviceModel element in the config file
               var section = ConfigurationManager.GetSection("system.serviceModel/services") as ServicesSection;
               if (section != null)
               {
                   foreach (ServiceElement element in section.Services)
                   {                                                
                       // NOTE : If the assembly is in another namespace, provide a fully qualified name here in the form
                       // <typename, namespace>                        
                       // For e.g. Business.Services.CustomerService, Business.Services

                       var serviceType = Type.GetType(element.Name);  // Get the typeName 
                       var host = new ServiceHost(serviceType);

                       hosts.Add(host);  // Add to the host collection
                       host.Open();      // Open the host
                   }
               }

               Console.ReadLine();
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
               Console.ReadLine();
           }
           finally
           {
               foreach (ServiceHost host in hosts)
               {
                   if (host.State == CommunicationState.Opened)
                   {
                       host.Close();
                   }
                   else
                   {
                       host.Abort();
                   }
               }
           }
       }
   }

I hope you find this useful. You can make this as a windows service if required.

WCF 2 - Building Blocks

Rajesh Pillai — Sun, 20 Dec 2009 15:44:13 GMT

Building Blocks of Service

Service is a

Collection of operations that are exposed to the clients.
Service contract defines what operations are available and how clients use them.
Data contract describes data that the client and service can exchange.

Service Contracts

Describe the operations supported by a service, the message exhange pattern used and format of each
message.
ServiceContract attribute marks an interface as a service contract.
OperationContract attribute exposes methods of the interface.

Code snippet

[ServiceContract]
public interface IHelloService 
{
     [OperationContract]
     string SayHello (string yourName);
}

Data Contracts

A data contracts

Describes how CLR types are mapped to XSD schema definitions.
Enable complex types to be serialized and deserialized so it can be passed across.
DataContract attribute identiifes each class that can be serialized.
DataMember attribute identifies members that needs to be exposed to the clients.

Code snippet

Here's an example of a data contract for a account class.

[DataContract]

public class Account

{

    [DataMember]

    public sting AccountNo { get; set; }
    [DataMember]

    public sting AccountType { get; set; }

}

The DataContract is applied at the class level and the DataMember is applied at the individual member level.

Endpoints

The client communicates with service via endpoints.

Host application makes the service available by providing one or more endpoints to the clients.
Endpoint consist of
- Address of service (Where?)
- Binding (How?)
- Contract (What?)
Client and Service use the same endpoint.

Address-Binding-Contract are the ABC's of service.

Bindings

Specify how a service endpoint communicates with client endpoints.
Consist of binding elements describing some essential aspect of communication like
- Transport (HTTP, TCP, etc)
- Protocol (security, reliability, transctions, sessions etc)
- Messge encoding (text, binary etc)
Can be declared programatically or declaratively in the config file.

Out of box Bindings

BasicHttpBinding
Compatible with ASMX Web Services.
WSHttpBinding
- Conforms to WS* specifications for reliability, security and transactions.
- Default
WS2007HttpBinding
- Conforms to OASIS specifications for reliability, security and transactions.
WSDualHttpBinding
- Supports WS-* + two-way communication
WSFederationBinding
- Supports the WS-Federation specification for sharing identities across multiple systems.
WS2007FederationBinding
- Supports federated security.
NetTcpBinding
- Communicates across processes and machines.
NetNamedPipeBinding
- Communicates on same machine
NetPeerBinding
- Peer to peer communications over TCP
NetMsmqBinding
- Uses MSMQ to transmit messages
MsmqIntegrationBinding
- Service can send or receive messages from a MSMQ queue.

The most frequently used binding is the BasicHttpBinding, the WSHttpBinding and the NetTcpBinding.

That's it for now!!!

WCF 1 - Introduction

Rajesh Pillai — Sun, 20 Dec 2009 06:45:16 GMT

What is WCF?

Windows Communication Foundation aka WCF is a Microsoft platform for SOA
(Service Oriented Architecture). The following are some of the important aspects that WCF allows us to achieve.

Its used for building distributed and interoperatble applications.
Unifies ASMX, .NET Remoting, Enterprise Services, MSMQ etc.
A single programming model for all distributed computing technology.
Configuration driven protocol choices, messaging format, reliable transactions etc.
Built for service-oriented system design
Loosely coupled. Not bound to a particular protocol, encoding format or hosting environmnet.

Its built on top of .NET and is available with .net framework 3.0 and 3.5. The overall WCF structure revolves around the following three core contracts.

Service Contract Defines which operations on the service can be invoked by the client.
Data Contract Defines the structure of data included in the payloads of the messages flowing in
and out of the service.
Message Contract Enables the developer to control the headers that appear in the messages and how
the messages are structured.

Real World Consideration

To design real world service contracts, we have leave our object oriented thinking behind. We have to think in
terms of messages. Messages are flowing in and out of the system. For instance, you might have a
SignatureScanningService that would recieve a SignatureDocuments in a message payload, which would in turn
trigger the processing of signature. This is typically used in banks wherein the clients signature needs to
be captured and processed. You can also consider the example of LoanProcessingApplication. The processing
may be a long running task, in that case some kind of acknowledgement should be return frrm the service to the
client. We have to move towards more document centric thinking.

WCF and Web Services Standards

The WCF contrcts directly maps to the following web services in the following way.

Service contracts map to WSDL (Web Service Description Language)
Data contracts map to XSD (xTensibile Schema Definition)
Message contracts map to SOAP (Simple Object Access Protocol) [The abbreviation is no longer important
as SOAP is more that a simple object access).

SOA (Service Oriented Architecture)

The following points briefly highlights the essence of SOA.

A service is a program that performs some task and the client can interact with the service using well-defined
contracts.
A service-oriented applciation consists of loosely coupled services that communicates through messages
and contracts. They directly don't instantiate the service but interacts through messages.

Principles

Boundaries are explicit
- Services communicate by sending messages across their boundary.
- All communication occur through messages.
Services are autonomous
- Services are build, managed and version independently.
- Services can be changed without affecting clients as long as clients can continue sending and receiving
the same messages.
Services share contracts and schema
- Contracts describe the messages services can send and receive.
- Schemas define how the client and service construct the messages they exchange.
Compatibility is policy based
- Services can define the policiies under which the clients can communicate with them.

In the next post we will quickly have a look at the building blocks of WCF and continue our discussion on
contracts, services, data and messages...

Cheers till then !!