WCF Web Services The Easy Way

I’m gonna go ahead and say it… I don’t think WCF is all that bad. In fact, I think it can be pretty easy! I hear lots of complaints about it, and many of them valid, but by far the biggest complaint I hear is that it is just so darn difficult. Especially cause of all that xml configuration. Holy crap I hate XML configuration! (If you want to complain some more, I’m on Twitter) And because it is perceived as difficult, it is often overlooked in favor of ASMX web services because they "just work".

While normally I would be the first in line to use a tool that "just works", in this case I think that WCF is carrying around baggage of its earlier incarnations. I want to show you that as of .NET 3.5, WCF can be just as easy for setting up web services as ASMX, and that you no longer need to fear it. Or fear the day that Microsoft deprecates ASMX web services.

In fact, we are going to setup WCF web services without any configuration! In order to get started, let’s go ahead and add a WCF web service to our project:

We should be able to now see our service sitting in our project:

You probably also see the interface that it created, we don’t need that right now, you can go ahead and delete that. I hear the purists getting their panties in a bunch right now, just calm down.

If we double click our service to open it up, we will see that we now have to remove the interface declaration on the service as well:

public class MyTestService : IMyTestService
{
    public void DoWork()
    {
    }
}

Once we remove it, change it so that it returns a value, and move our contract attributes which were previously on the interface, it now looks like this:

[ServiceContract]
public class MyTestService
{
    [OperationContract]
    public string DoWork()
    {
        return "Did Something!";
    }
}

Okay, so this is the part where we start putting in a bunch of xml configuration, right? Wrong. This is the part where our little friend ServiceHostFactory comes to the rescue. The first thing we need to do is write click on the .svc file and click "View Markup". Yeah, it is weird that you have to click "View Markup", but don’t look at me, I didn’t write it.

After you click "View Markup" you’ll be looking at the XML that binds the .svc file to the implementation of your service. It should look like this:

<%@ ServiceHost Language="C#" 
    Debug="true" 
    Service="MyTestWebsite.MyTestService" 
    CodeBehind="MyTestService.svc.cs"  %>

Now we can add one single attribute called "factory" and remove the Debug and CodeBehind attributes (unless you are running as a website and not a web project):

<%@ ServiceHost Language="C#"
    Service="MyTestWebsite.MyTestService" 
    Factory="System.ServiceModel.Activation.ServiceHostFactory" %>

Now if we hit the service, what do we get? We get the WCF service screen. We can click the link to view the WSDL or we can do what it says and use svcutil to generate a client.

To make it even more simple, you could move the code for the service out of the CodeBehind file and into the .svc file. Now you have an entire WCF service in a single file! Check it out:

<%@ ServiceHost Language="C#"
    Service="MyTestWebsite.MyTestService"
    Factory="System.ServiceModel.Activation.ServiceHostFactory" %>
using System.ServiceModel;

namespace MyTestWebsite
{
    [ServiceContract]
    public class MyTestService
    {
        [OperationContract]
        public string DoWork()
        {
            return "Did Something!";
        }
    }
}

Did you know that was even possible? Go ahead, check the service, it still works! And you know what else we can do? What if we want to make it a REST web service which can return JSON? We just have to do a few things.

First we need to change ServiceHostFactory to WebServiceHostFactory, then we just add a "WebGet" attribute to the operation contract. Next we have to change the result type to Stream so that we can use the JavaScriptSerializer instead of the stupid DataContractSerializer which requires a bunch of attributes on the serialized classes.

Now our service looks like this:

<%@ ServiceHost Language="C#"
    Service="MyTestWebsite.MyTestService"
    Factory="System.ServiceModel.Activation.WebServiceHostFactory" %>
using System.IO;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Web.Script.Serialization;

namespace MyTestWebsite
{
    [ServiceContract]
    public class MyTestService
    {
        [OperationContract]
        [WebGet]
        public Stream DoWork()
        {
            return WriteJson(new { MyValue = "Did Something!" });
        }

        private Stream WriteJson(object value)
        {
            var javaScriptSerializer = new JavaScriptSerializer();
            var json = 
                Encoding.UTF8.GetBytes(javaScriptSerializer.Serialize(value));
            var memoryStream = new MemoryStream(json);
            WebOperationContext.Current.OutgoingResponse.ContentType 
                = "application/json; charset=utf-8";
            return memoryStream;
        }
    }
}

And that is it, we just hit the url at MyTestService.svc/DoWork and we get a chunk of JSON returned:

Now we had to add a single method in order to allow us to write a raw JSON response, I hope you’ll agree that since you have the code to do it now, it really isn’t that hard!

Hopefully you found this post useful, and I hope that if you have overlooked WCF services because you hate all of the configuration (I know I did!), that you’ll give them a second look.

One last note, if you are using ASP.NET MVC then you already have a much easier method of doing JSON REST web services, so please don’t do this! 🙂