Back to Questions
3.5k
views2
comments
WCF Service in F#: Any ideas?
f#webclasses

I've created a dummy web service in F# and I'm surprise that it's so much code (see below). There's two problems:

  1. WCF requires a name for the root element of the request message (input parameter). Normally it picks the name of the input parameter in the interface definition. This works well in C# but in F# the interface definition specifies only types. That's certainly not bad but the only solution I can find is wrapping my DataContract in a MessageContract. I saw an example on the net where the implementing class had the ServiceContract attribute but I really prefer to create a separate interface definition.
  2. The DataContract and MessageContract classes need to have mutable fields. It shows that F# isn't very fond about them. Neither am I, I'd rather have them immutable, but the DataContractSerializer needs it: I suspect that when it woud have to support initializing objects through the constructor when deserializing it would have to do that from the inside out (i.e. child objects first) while it now works in the opposite direction.

Anyway, I don't see a way to make the code smaller. Can anyone suggest improvements?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

open System.Runtime.Serialization
open System.ServiceModel

module Namespace =
    [<Literal>]
    let Mine = "urn:mine:myservice"

[<DataContract(Namespace = Namespace.Mine)>]
type MyMethodRequest() =
    let mutable parameter1 = 0
    let mutable parameter2 = 0m
    [<DataMember>]
    member r.Parameter1 with get() = parameter1 and set(p1) = parameter1 <- p1
    [<DataMember>]
    member r.Parameter2 with get() = parameter2 and set(p2) = parameter2 <- p2

[<DataContract(Namespace = Namespace.Mine)>]
type MyMethodResult() =
    let mutable parameter3 = 0m
    [<DataMember>]
    member r.Parameter3 with get() = parameter3 and set(p) = parameter3 <- p

[<MessageContract>]
type MyMethod() =
    let mutable request:MyMethodRequest = new MyMethodRequest()
    [<MessageBodyMember>]
    member m.Request with get() = request and set(r) = request <- r
    
[<MessageContract>]
type MyMethodResponse() =
    let mutable result:MyMethodResult = new MyMethodResult()
    [<MessageBodyMember>]
    member m.Result with get() = result and set(r) = result <- r

[<ServiceContract(Namespace = Namespace.Mine)>]
type IMyService =
    [<OperationContract>]
    abstract MyMethod: MyMethod -> MyMethodResponse

[<ServiceBehavior(Namespace = Namespace.Mine)>]
type MyService() =
    interface IMyService with
        member l.MyMethod (request:MyMethod) =
            new MyMethodResponse(Result = new MyMethodResult(Parameter3 = 100m))
.

You can specify names on F# interfaces, so here's the version that gets rid of the need for MessageContract:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

open System.Runtime.Serialization
open System.ServiceModel

module Namespace =
    [<Literal>]
    let Mine = "urn:mine:myservice"

[<DataContract(Namespace = Namespace.Mine)>]
type MyMethodRequest() =
    let mutable parameter1 = 0
    let mutable parameter2 = 0m
    [<DataMember>]
    member r.Parameter1 with get() = parameter1 and set(p1) = parameter1 <- p1
    [<DataMember>]
    member r.Parameter2 with get() = parameter2 and set(p2) = parameter2 <- p2

[<DataContract(Namespace = Namespace.Mine)>]
type MyMethodResult() =
    let mutable parameter3 = 0m
    [<DataMember>]
    member r.Parameter3 with get() = parameter3 and set(p) = parameter3 <- p

[<ServiceContract(Namespace = Namespace.Mine)>]
type IMyService =
    [<OperationContract>]
    abstract MyMethod: req:MyMethodRequest -> MyMethodResult

[<ServiceBehavior(Namespace = Namespace.Mine)>]
type MyService() =
    interface IMyService with
        member l.MyMethod (request:MyMethodRequest) =
            new MyMethodResult(Parameter3 = 100m)

I'm not sure offhand about the DataContract issue.

By on 10/3/2008 1:21 PM ()

Thanks! That was easier than I thought. I think the immutable object thing is harder. I was thinking that maybe something is possible with the IDataContractSurrogate but I haven't looked into it and in any I don't expect the code to become smaller.

By on 10/3/2008 2:48 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper