Back to Questions
2.8k
views8
comments
Record serialization
f#compiler

I would like to serialize this example record:

1
2
3

type Book =
  { mutable Title  : string;
    mutable Author : string }

But the XmlSerializer cannot serialize the record because it does not have a parameterless constructor. I have suggested in an earlier thread that it should be possible to define default values for record items. If defined the compiler could also add an empty constructor for the example record above and the record could be serialized.

It's of course possible use a constructed class to simulate records, but then you lose the nice clean record syntax and must use fields, getters and setters:

1
2
3
4
5

type Book() =
    let mutable title = ""
    let mutable author = ""
    member x.Title with get () = title and set t = title <- t
    member x.Author with get () = author and set a = author <- a

Edit: the forum doesn't show the assignment operator.

.

I agree this annoying but it doesn't seem logical to me to an empty constructor on a record especially as the default for records is to be immutable.

To me it seems more like a fault in the implementation of the xml serializer, which demands an empty constructor.

Have you considered using the binary serializer which supports types without an empty constructor?

Or maybe you could just write a parser to parse the XML and construct the records? F#'s reflection APIs provide simple methods to construct record types dynamically and there are lots of different XML parser in .NET that are relatively simple to use. I know this is more work but it would give you more control over the format and you could use reflection to make it work with any F# record if you wanted to?

By on 10/2/2008 3:59 AM ()

The compiler would only add an empty constructor if all record items have default values. The default record then functions like a prototype:

1
2

let defaultBook = {new Book}

I like Ray's solution. I assumed that the DataContractSerializer also required an empty contructor.

By on 10/2/2008 7:26 AM ()

The DataContractSerializer actually works more like the BinaryFormatter where I believe it uses reflection to get at the instance fields. From my reading, I believe that the DataContract model was created to address the issues that you and Robert noted (and more) but it introduces a very flexible approach to serialization. And it works just fine apart from WCF. :)

I'm glad that you liked the example.

By on 10/2/2008 7:54 AM ()

I just wanted to add to the record that the DataContractSerializer also honors the Serializable attribute. Mark your record types with this attribute and you can serialize them using DataContractSerializer. Some rules apply, for instance, your record type's fields must also be serializable.

My previous example works just as well if you define Book like this:

1
2
3
4

[<Serializable>]
type Book =
    { mutable Title : string;
      mutable Author : string }
By on 10/5/2008 7:13 PM ()

According to this article only .NET 3.5 SP1 supports that. Also when i tried to serialize a record without attributes the fields with underscores generated by the compiler were serialized instead of the record properties because the compiler makes those fields public for mutable record items.

I've read that Silverlight has an opt-out model for DataContracts so i assume that it has the same behavior. I'd like to test it but using F# with Silverlight is difficult at the moment.

By on 10/6/2008 3:14 AM ()

And as a further addendum, the F# compiler automatically adds the Serializable attribute to record types...so basically you can just pass your record types as-is to the DataContractSerializer. :)

By on 10/5/2008 7:20 PM ()

I still feel that unification of record and class syntax would offer much to the language. The ability to define a class with a lightweight property syntax would help communicate the classes' contents and meaning very transparently.

1
2
3
4
5

type Person() =
    First : mutable "John" 
    Last  : mutable "Doe" 

    override x.ToString() = x.First + " " + x.Second

I'm not sure that this is viable, but it would stop classes like the following one (specifically written to work with XmlSerializer)

1
2
3
4
5
6

type Person(?first, ?second) =
    let mutable first = defaultArg first "John"
    let mutable second = defaultArg second "Doe"
    member this.First with get () = first and set v = first <- v
    member this.Second with get () = second and set v = second <- v
    override x.ToString() = first + " " + second

Glancing between the two definitions it seems apparent which one reads better.

I do like RayV's suggestion and will look into it.

By on 10/2/2008 10:07 AM ()

If you're amenable to using the rather new DataContractSerializer, you can serialize record types to XML just by applying a couple of attributes. Here's a full example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#light
#r "System.Runtime.Serialization"
open System.IO
open System.Runtime.Serialization


[<DataContract>]
type Book =
    { [<DataMember>] mutable Title : string;
      [<DataMember>] mutable Author : string }
      

let stream = new MemoryStream()
let serializer = new DataContractSerializer(typeof<Book>)
let book = { Title = "Expert F#"; Author = "Don Syme, Adam Granicz, and Antonio Cisternino" }


serializer.WriteObject(stream, book)
stream.Position <- int64 0


let reader = new StreamReader(stream)
printfn "%s" (reader.ReadToEnd())
By on 10/2/2008 3:55 AM ()

    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