F# does a WCF Service


I spent a large portion of my career working with WS-*/SOAP. So, once I understood how F# attributes worked, I thought it would be cool to see if I could write a WCF service. Nothing complex– I just wanted to see if I could get HelloWorld up and running. Given that one can get a class running as a service with the right config and .svc file, this seemed like an easy task. First, I’ll present the solution, then I’ll talk about a couple of issues I ran into along the way to the solution. In F#, one adds attributes by placing a [<Attribute>] before the type or member. For WCF, we need the ServiceContractAttribute and OperationContractAttribute on the type and any exposed functions. The HelloWorld service can be written like this:

 

    1 #light

    2 

    3 namespace Service

    4     open System.ServiceModel

    5 

    6     [<ServiceContract>]

    7     type MyContract =

    8            new() = {}

    9            [<OperationContract>]

   10            member x.HelloWorld(name: string)= “Hello, “ + name

 

Following the path most folks take, hosting in IIS, we next write a .svc file with the following content:

<%@ ServiceHost Service=”Service.MyContract”  %>

This just tells the ServiceHostFactory to instantiate an object of type Service.MyContract whenever a request comes in. Finally, we go into web.config and add the following markup:

 

    1     <system.serviceModel>

    2         <behaviors>

    3             <serviceBehaviors>

    4                 <behavior name=SimpleService.SimpleServiceBehavior>

    5                     <serviceMetadata httpGetEnabled=true/>

    6                     <serviceDebug includeExceptionDetailInFaults=false/>

    7                 </behavior>

    8             </serviceBehaviors>

    9         </behaviors>

   10         <services>

   11             <service behaviorConfiguration=SimpleService.SimpleServiceBehavior name=Service.MyContract>

   12                 <endpoint address=“” binding=wsHttpBinding contract=Service.MyContract>

   13                     <identity>

   14                         <dns value=localhost/>

   15                     </identity>

   16                 </endpoint>

   17                 <endpoint address=mex binding=mexHttpBinding contract=IMetadataExchange/>

   18             </service>

   19         </services>

   20     </system.serviceModel>

Finally, I wrote a client application in C#, using Add Service Reference in VS2008 to generate the client code.

 

    1 class Program

    2 {

    3     static void Main(string[] args)

    4     {

    5         using (ServiceReference1.MyContractClient client = new SimpleClient.ServiceReference1.MyContractClient())

    6         {

    7             Console.WriteLine(client.HelloWorld(“Scott”));

    8         }

    9     }

   10 }

And it all worked just fine. I know– it’s all .NET and that’s the way things should work. I’m most impressed by the terseness of F#.

OK, so what did I learn while doing this? First off, F# does NOT create a default, empty constructor for classes. WCF barked at me when I tried to access the SVC file, stating that it couldn’t create the object because the object lacked a default constructor. So, I dug into the F# spec and learned that a default, do nothing constructor looks like

 

           new() = {}

I also tried doing this in the traditional way, with an interface definition first and then an implementation of the interface. That didn’t work so well. In F#, the interface looks like this:

 

    [<ServiceContract>]

    type IMyContract =

            [<OperationContract>]

            abstract HelloWorld : string -> string

 

That little bit on HelloWorld states that the input is a single string that yields a string. The input parameter does not have a name, and that’s a problem. No name means no name, null, in F#. When System.ServiceModel does its reflection thing to figure out what the name of the parameter in the message should be, it sees a null and throws up its hands. I was able to name the parameter only when applying the attributes on the named parameter in the implementation. So, I ditched the interface. Maybe I missed something that would allow me to name the parameter, but I’m not too sure what it could be. For now, I’ll assume that this was a legitimate issue. I’ll update this post if I learn otherwise.

  1. Leave a comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: