Exploring WCF

I have been learning Windows Communication Foundation (WCF) recently.  While there are a LOT of frustrations involved with it, it is leaps and bounds better than what was previously available in the .Net world.

One thing I have discovered about WCF though is that there is precious little information about it available (in comparison to other .Net related topics) .  With that in mind, I thought I would start sharing some of the things that I am learning.

First of all WCF does its work through contracts.  The two main types of contracts that we’ll focus on here are Service Contracts, Operation Contracts, and Data Contracts.  A Service Contract describes which operations the client can perform on the service. Operation Contracts expose a method as a operation to perform as part of the service. Data Contracts define which data types are passed to and from the service.

The contracts are applied to your classes, methods, variables as attributes.
For instance:

[ServiceContract] 
interface ISample {  
    //Will be included in the service 
    [OperationContract] 
    string SayHelloSample(string name); 

    //Not included as part of the service 
    string SayGoodbyeSample(string name); 
}

In the above example, we are defining an interface for a service and exposing SayHelloSample as a operation for that service.  Only classes/interfaces with the ServiceContract attribute and methods with OperationContract will be recognized by WCF.

So, now that we’ve covered some of the basics, let’s jump into a project…

Using Visual Studio Click on File + > + New Project.
Choose your favorite language and the Select Web in the tree and select WCF Service Application
Visual Studio will stub out a service for you automatically.

You will have 3 files for each service you create.

  • An Interface for the service – ISample.cs
    It is generally considered best practice (and in fact WCF was designed with this in mind) to define your contracts in a separate interface that you then use to implement your service in a separate class.
  • The Service file itself – Sample.svc
    The “visible” file people will connect to when calling your service
  • The Code-Behind for the Service – Sample.svc.cs
    This is where you will code the behavior for the operations defined in the contract interface.**

Visual Studio implements the infamous “Hello World” to lay out a simple service for you to start from.

Let’s start by examining the interface.  The first thing to notice will be the namespaces that are imported to support WCF (System.Runtime.Serialization and System.ServiceModel).  If you are going to add contracts to any existing classes or objects you may have, then you will need to make sure these two namespaces are included in your using/imports.

The interface defined here will have two methods: GetData and GetDataUsingDataContract.  Given the similarity to the previous interface sample I have already shown, I won’t write out the code here, but notice that the Service and Operation contract attributes are on the interface and methods.

Under the interface you should see a class defined called CompositeType.  Here is an example of a Data Contract.

[DataContract] 
public class CompositeType {  
    bool boolValue = true; 
    string stringValue = "Hello "; 

    [DataMember] 
    public bool BoolValue { 
        get { return boolValue; } 
        set { boolValue = value; } 
    } 

    [DataMember] 
    public string StringValue { 
        get { return stringValue; } 
        set { stringValue = value; } 
    } 
}

You will notice the DataContract attribute applied to the class.  This is telling WCF that we want this class/struct to be part of our service contract and to serialize it for incoming/outgoing messages. Inside the class/struct itself, for each property / variable that we would like WCF to take not of and serialize, we decorate it with the DataMember attribute.  Much like with the OperationContracts, anything that does NOT have the DataMember attribute will be ignored by WCF.

Looking at the code behind that was generated for our service, we will see that it is inheriting from the contract interface.  Notice here that because the contracts were already specified in the interface, we do not specify them here on the class itself.

public class Sample : ISample {  
    public string GetData(int value) { 
        return string.Format("You entered: {0}", value); 
    } 

    public CompositeType GetDataUsingDataContract(CompositeType composite) { 
        if (composite.BoolValue) { 
            composite.StringValue += "Suffix"; 
        } 
        return composite; 
    } 
}

When GetDataUsingDataContract is called, WCF will take care of serializing the CompositeType class to the appropriate format depending on what kind of service you are developing.  In this case, XML. Also, be sure to open the web.config and look at the new system.ServiceModel section at the bottom.  This is where the service gets exposed/defined and will be where you will configure the security and accessibility of your service.  I will be writing more on this in the future.

As you can imagine, if you have existing code already written with custom objects / methods, by simply adding the appropriate attributes, it becomes very simple to expose them via WCF.

I highly encourage everyone to dig into WCF and poke around.  It is an incredibly robust and powerful framework and is a definite step forward for .Net based services.