In .NET 4.0, initial ramp-up with WCF services has been greatly simplified. This bare bones guide gets you up and running with the basics in about 10 minutes, without any of the onerous XML file hacking that WCF has been known for.

This post assumes you are working with Visual Studio 2010 and the 4.0 version of the .NET framework.

Starting Up – The Host

Our simple example will consist of two console applications, a host and a client. Our service will be a string reversal service. We will start with the host.

We start with a new console application, adding a reference to System.ServiceModel.

Next we define our service interface. Note the attributes that we decorate the interface and method with.

[ServiceContract]
 public interface IReverserService
 {
 [OperationContract]
 string Reverse(string input);
 }

We need the System.ServiceModel namespace for the attributes that tell the framework that this is a service contract. We then decorate the class with the ServiceContract attribute, and the method with the OperationContract attribute.

Next up is our implementation.

public class ReverserService : IReverserService
 {
 public string Reverse(string input)
 {
 char[] i = input.ToCharArray();
 Array.Reverse(i);
 return new String(i);
 }
 }

Nothing fancy going on here, just a simple implementation of string reversal.

Finally, we modify the main method of the console application to host our service.

class Program
 {
 static void Main(string[] args)
 {
 using (ServiceHost host = new ServiceHost(typeof(ReverserService),new Uri("net.tcp://localhost:9000")))
 {
 host.Description.Behaviors.Add(new ServiceMetadataBehavior());
 host.AddServiceEndpoint(typeof(IMetadataExchange),MetadataExchangeBindings.CreateMexTcpBinding(),"mex");
 host.AddServiceEndpoint(typeof(IReverserService),new NetTcpBinding(),"net.tcp://localhost:9000/ReverserService");
 host.Open();
 Console.WriteLine("press enter to stop service...");
 Console.ReadLine();

 host.Close();
 }
 }
 }

Things get a lot more interesting here. Note that we could reduce the code if we added some configuration to our app.config; given that one of the goals of this post was to demonstrate a simple WCF service scenario without XML fun, we are eschewing that option.

We start by declaring a new ServiceHost for our service. This is the class that will be listening for incoming requests. We want our service to be functional but also descriptive; this is what the next 2 lines do for us. We are enabling metadata exchange by adding the corresponding behavior and endpoint. The endpoint addition required inclusion of the System.ServiceModel.Description namespace so that we could specify the type of binding we wanted for our metadata endpoint.

The next line adds our actual service endpoint – this is what clients will use for to reverse their strings. Next, we start our host and await client calls until someone presses a key. Pretty simple, and again, zero configuration. Building and running our solution produces the grand display of functionality below.

Service Running

The Client

Leaving our host running, we start up another instance of Visual Studio 2010 and begin a new console application. We now add a new service reference as below.

Note the URI that we typed in the address box. This is using the metadata exchange endpoint that we configured in the host, and makes it terribly straightforward to both get a reference to our service and to write the code that will use the service.

static void Main(string[] args)
 {
 ReverserService.ReverserServiceClient reverser = new ReverserService.ReverserServiceClient();

 string st = "";
 Console.Write("Enter a String to sent it to the service (e for exit) : ");
 st = Console.ReadLine();
 while (st != "e")
 {
 string reversed = reverser.Reverse(st);
 Console.WriteLine("Response : " + reversed);

 Console.Write("Enter a String to sent it to the service (e for exit) : ");
 st = Console.ReadLine();
 }

 reverser.Close();
 }

Adding the service reference the way we did instructed Visual Studio 2010 to pull down the service definition and generate code based on this service definition. It’s this generated code that allows us to write the first two lines in the main method as cleanly as we did; we simply instantiate the generated class and call the method. The only other (very important) use of the generated class is the last line in the method where we close out the connection. Running our test client (again, ensure that the host is still running) gives us the below.

Client using My Service

Download Projects

Source : http://www.barebonescoder.com/2011/01/wcf-services-with-net-4-0/