4

基本上我想要一个单一的结构来处理序列化到 JSON 和格式化的 xml。记录在序列化到/从 json 方面工作得很好。然而 XmlSerializer 需要一个无参数的构造器。我真的不想经历为这些构造构建类对象的练习（仅原理）。我希望有一些捷径可以将无参数构造函数添加到记录中（可能使用 wioth 语句或其他东西）。我无法让它表现出来 - 社区中是否有人运气好？

module JSONExample
    open System
    open System.IO 
    open System.Net 
    open System.Text 
    open System.Web 
    open System.Xml
    open System.Security.Authentication 
    open System.Runtime.Serialization //add assemnbly reference System.Runtime.Serialization System.Xml
    open System.Xml.Serialization
    open System.Collections.Generic 

    [<DataContract>]            
    type ChemicalElementRecord = { 
        [<XmlAttribute("name")>]
        [<field: DataMember(Name="name") >] 
        Name:string 

        [<XmlAttribute("name")>]
        [<field: DataMember(Name="boiling_point") >] 
        BoilingPoint:string 

        [<XmlAttribute("atomic-mass")>]
        [<field: DataMember(Name="atomic_mass") >] 
        AtomicMass:string 
    } 

    [<XmlRoot("freebase")>]
    [<DataContract>] 
    type FreebaseResultRecord = { 
        [<XmlAttribute("code")>]
        [<field: DataMember(Name="code") >] 
        Code:string 

        [<XmlArrayAttribute("results")>]
        [<XmlArrayItem(typeof<ChemicalElementRecord>, ElementName = "chemical-element")>]
        [<field: DataMember(Name="result") >] 
        Result: ChemicalElementRecord array

        [<XmlElement("message")>] 
        [<field: DataMember(Name="message") >] 
        Message:string 
        } 


    let getJsonFromWeb() = 
        let query = "[{'type':'/chemistry/chemical_element','name':null,'boiling_point':null,'atomic_mass':null}]"
        let query = query.Replace("'","\"") 
        let queryUrl = sprintf "http://api.freebase.com/api/service/mqlread?query=%s" "{\"query\":"+query+"}" 

        let request : HttpWebRequest = downcast WebRequest.Create(queryUrl) 
        request.Method <- "GET" 
        request.ContentType <- "application/x-www-form-urlencoded" 

        let response = request.GetResponse() 

        let result = 
            try 
                use reader = new StreamReader(response.GetResponseStream()) 
                reader.ReadToEnd(); 
            finally 
                response.Close() 

        let data = Encoding.Unicode.GetBytes(result); 
        let stream = new MemoryStream() 
        stream.Write(data, 0, data.Length); 
        stream.Position <- 0L 
        stream



    let test =
        // get some JSON from the web
        let stream = getJsonFromWeb()

        // convert the stream of JSON into an F# Record
        let JsonSerializer = Json.DataContractJsonSerializer(typeof<FreebaseResultRecord>) 
        let result: FreebaseResultRecord = downcast JsonSerializer.ReadObject(stream) 

        // save the Records to disk as JSON 
        use fs = new FileStream(@"C:\temp\freebase.json", FileMode.Create) 
        JsonSerializer.WriteObject(fs,result)
        fs.Close()

        // save the Records to disk as System Controlled XML
        let xmlSerializer = DataContractSerializer(typeof<FreebaseResultRecord>);
        use fs = new FileStream(@"C:\temp\freebase.xml", FileMode.Create) 
        xmlSerializer.WriteObject(fs,result)
        fs.Close()

        use fs = new FileStream(@"C:\temp\freebase-pretty.xml", FileMode.Create) 
        let xmlSerializer = XmlSerializer(typeof<FreebaseResultRecord>)
        xmlSerializer.Serialize(fs,result)
        fs.Close()

ignore(test)
4

3 回答 3

8

Blockquote 我希望有一些捷径可以将无参数构造函数添加到记录中

通过使用CLIMutable属性，这在 F# 版本 3.0 中是可能的。将此添加到无参数构造函数和读/写属性（而不是只读属性）的记录类型中。

于 2012-10-29T18:06:28.593 回答
1

为什么不使用 DataContractSerializer（用于 Xml）而不是 XmlSerializer？这是数据合约的主要好处之一（多个投影的相同编程模型）。

（无法为 F# 记录创建无参数构造函数。）

于 2010-06-09T16:49:54.833 回答
1

看起来您无法将记录更改为类 - 或向其添加 edfault 构造函数。

提供的示例（基于本文： http: //blogs.msdn.com/b/jomo_fisher/archive/2010/03/06/neat-sample-f-and-freebase.aspx）从 api 获取 json 流.freebase.com；然后我们反序列化为属性类；接下来将其作为 Json 序列化到磁盘；然后将其作为 Xml 序列化到磁盘（使用 DataContract）；最后，通过对输出的最佳控制，将其作为 Xml 序列化到磁盘（使用 XmlSerializer）：

笔记：

DataContractJsonSerializer 和 JSON.DataContractJsonSerializer 的 DataContract(family of) 属性 - 这些出现在类名和成员变量上。DataContract 的东西很简单——也适用于记录类型。

类和 Property Getter/Setter 上的 XmlSerializer(family of) 属性。这要求类型是一个具有默认构造函数的对象，以及与每个相关联的属性 Getter 和 Setter。如果一个 Property 没有 getter 或 setter 它不会序列化 - 这是一个惊喜（我想象默认的 onstructor 将确保对象在反序列化时具有 defulat 值，并且 setter 将使用序列化的任何内容进行更新 - 但没有事实并非如此）。

关于 XmlSerialization 的另一个漂亮（叹气）的事情是类不能包含在模块中。所以我们将类型移动到命名空间......

namespace JSONExample
    open System
    open System.IO 
    open System.Net 
    open System.Text 
    open System.Web 
    open System.Xml
    open System.Security.Authentication 
    open System.Runtime.Serialization //add assemnbly reference System.Runtime.Serialization System.Xml
    open System.Xml.Serialization
    open System.Collections.Generic 

    [<DataContract>]            
    type ChemicalElementRecord() =  
        [<field: DataMember(Name="name") >] 
        let mutable name: string  = ""

        [<field: DataMember(Name="boiling_point") >] 
        let mutable boilingPoint: string =""

        [<field: DataMember(Name="atomic_mass") >] 
        let mutable atomicMass: string  = ""

        [<XmlAttribute("name")>]
        member this.Name with get() = name and set v = name <- v

        [<XmlAttribute("boiling-point")>]
        member this.BoilingPoint with get()  = boilingPoint  and set v = boilingPoint <- v

        [<XmlAttribute("atomic-mass")>]
        member this.AtomicMass with get() = atomicMass  and set v = atomicMass <- v

    [<XmlRoot("freebase")>]
    [<DataContract>] 
    type FreebaseResultRecord() =  

        [<field: DataMember(Name="code") >] 
        let mutable code: string = ""

        [<field: DataMember(Name="result") >] 
        let mutable result: ChemicalElementRecord array = Array.empty

        [<field: DataMember(Name="message") >] 
        let mutable message: string = ""

        [<XmlElement("message")>] 
        member this.Message with get() : string = message and set v = message <- v

        [<XmlArrayAttribute("chemical-elements")>]
        [<XmlArrayItem(typeof<ChemicalElementRecord>, ElementName = "chemical-element")>]
        member this.Result with get() = result and set v = result <- v

        [<XmlAttribute("code")>]
        member this.Code with get() = code and set v = code <- v

    module Test = 
        let getJsonFromWeb() = 
            let query = "[{'type':'/chemistry/chemical_element','name':null,'boiling_point':null,'atomic_mass':null}]"
            let query = query.Replace("'","\"") 
            let queryUrl = sprintf "http://api.freebase.com/api/service/mqlread?query=%s" "{\"query\":"+query+"}" 

            let request : HttpWebRequest = downcast WebRequest.Create(queryUrl) 
            request.Method <- "GET" 
            request.ContentType <- "application/x-www-form-urlencoded" 

            let response = request.GetResponse() 

            let result = 
                try 
                    use reader = new StreamReader(response.GetResponseStream()) 
                    reader.ReadToEnd(); 
                finally 
                    response.Close() 

            let data = Encoding.Unicode.GetBytes(result); 
            let stream = new MemoryStream() 
            stream.Write(data, 0, data.Length); 
            stream.Position <- 0L 
            stream



        let test =
            // get some JSON from the web
            let stream = getJsonFromWeb()

            // convert the stream of JSON into an F# Record
            let JsonSerializer = Json.DataContractJsonSerializer(typeof<FreebaseResultRecord>) 
            let result: FreebaseResultRecord = downcast JsonSerializer.ReadObject(stream) 

            // save the Records to disk as JSON 
            use fs = new FileStream(@"C:\temp\freebase.json", FileMode.Create) 
            JsonSerializer.WriteObject(fs,result)
            fs.Close()

            // save the Records to disk as System Controlled XML
            let xmlSerializer = DataContractSerializer(typeof<FreebaseResultRecord>);
            use fs = new FileStream(@"C:\temp\freebase.xml", FileMode.Create) 
            xmlSerializer.WriteObject(fs,result)
            fs.Close()

            use fs = new FileStream(@"C:\temp\freebase-pretty.xml", FileMode.Create) 
            let xmlSerializer = XmlSerializer(typeof<FreebaseResultRecord>)
            xmlSerializer.Serialize(fs,result)
            fs.Close()


        ignore(test)
于 2010-06-09T21:45:24.443 回答