Windows Communication Foundation takes many existing communication technologies, such as Web Services, Windows Remoting, Microsoft Message Queuing, and abstracts them into a single technology. In most cases, this simplifies the way you communicate with other applications. It also allows you to communicate with other applications without being coupled to a specific technology. Therefore, you could use Web Services over SOAP to begin with, and later move to remote procedure calls (RPC) without changing your code, just the configuration of WCF.
There are a few basic tasks when creating a WCF service. The basic tasks that must be performed are, in order:
- Define the service contract. A service contract specifies the signature of a service, the data it exchanges, and other contractually required data.
- Implement the contract. To implement a service contract, create the class that implements the contract and specify some custom behaviors that the runtime should have.
- Configure the service by specifying endpoint information and other behavior information.
- Host the service in an application.
- Build a client application.
To display a step-by-step enactment of the above steps, let’s define a web service that reports the current date/time:
1.1 Define a Service Contract
First, let’s create a project to house our service contract. Let’s call it WCFDateTime.Service.
1.2 Define a Service Contract
Then, let’s define an interface that represents the service we’re going to provide. In this case, let’s call it IDateTimeService.
1.3 Define a Service Contract
We need to add a method to our service that will return the current date/time:
1.4 Define a Service Contract
Now, we need to decorate our code with attributes so that WCF will recognize our interface and its methods. Namely, we will add the following attributes:
o Identifies an interface as a WCF service contract
o Identifies methods of an interface as WCF service operations, that is, methods that can be called through WCF
In order to use the above attributes, you’ll need to add a reference to the System.ServiceModel assembly. The service contract is now ready to be used.
2.1 Implement the Contract
Now that we’ve defined our service contract, we can move on to implementing it. First, let’s create another project to house our server application. Let’s call it WCFDateTime.Server, and make it a Console Application project.
2.2 Implement the Contract
Now, let’s implement the IDateTimeService. The implementation is going to run on our server, to provide the date/time to whoever is going to consume our service.
In the WCFDateTime.Server project, let’s create a class called DateTimeService and have it implement IDateTimeService:
Remember to add a reference to the WCFDateTime.Service project so you can use IDateTimeService.
2.3 Implement the Contract
The above code will obviously not compile, because we did not implement the GetCurrentDateTime method:
That’s it! The DateTimeService is now ready to be used.
3.1 Configure the Service
Now we need to configure our service so it can be consumed by client applications. The simplest way to accomplish this is by adding an application configuration file (app.config or web.config) to the WCFDateTime.Server project:
When defining an endpoint for WCF, remember your A-B-Cs:
1. Address (where)
2. Binding (how)
3. Contract (what)
The address specifies the address where you want the service to be located.
The binding specifies the transport you want to use in order to provide the service.
The contract specifies what service will be provided
4.1 Host the Service in an Application
Now that WCF has been configured, the simplest way to host this service is to create a Console Application and use the ServiceHost class. First, add a reference to the System.ServiceModel assembly. Then, In the program.cs file of WCFDateTime.Server, do the following:
By simply running this application, we expose our service so that client applications can use it.
5.1 Build a Client Application
To build a client application, we must create a new project for it. Let’s call it WCFDateTime.Client, and make it a Console Application as well.
5.2 Build a Client Application
Now, we need to add an Application Configuration file, and give it some settings that will allow us to connect to the service we just created:
Now that our we’ve configured our WCF client, we can connect to it. There are two ways to connect to the WCF service we previously created:
1. Client proxy generation
2. Channel factories
Most Microsoft articles will point you in the direction of using client proxies; however, for our purposes, channel factories are quicker to implement and more robust in a Model/View/Presenter architecture.
5.3 Build a Client Application
Now, add a reference to the System.ServiceModel and WCFDateTime.Service assemblies, and then add the following to the program.cs file:
5.4 Build a Client Application
Your client application is now ready to run! Simply start the WCFDateTime.Server application, and once it’s running, run the WCFDateTime.Client application to see it work!