PsAccelerator: May 2011

Tuesday, May 31, 2011

Create in F# XDocument with XDeclaration and namespace

In this example I will create the following XML in F#:

<?xml version="1.0" encoding="utf-8"?>

<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">

  <w:body>

    <w:p>

      <w:r>

        <w:t>This is a test</w:t>

      </w:r>

    </w:p>

  </w:body>

</w:document>

Transferring C#-code is not straightforward because the constructor of XDocument does not accept the following code: new  XDocument(new XDeclaration("1.0", "utf-8", "true"), new XElement("document"))

//First create some helpers:

let xnameNs str ns = XName.Get(str, ns)

let xname str =

    xnameNs str "http://schemas.openxmlformats.org/wordprocessingml/2006/main"

let ns = XNamespace.Get("http://schemas.openxmlformats.org/wordprocessingml/2006/main")

let dec = new XDeclaration("1.0", "utf-8", "true")

let el =

    new XElement(xname "document",

        new XAttribute(XNamespace.Xmlns + "w", ns),

            new XElement(xname "body",

                new XElement(xname "p",

                    new XElement(xname "r",

                        new XElement(xname "t", "This is a test")

                        ))))

//Add them together:

let document =

    let doc =new XDocument(dec)

    doc.AddFirst(el)

doc

//And test:

document.Save(@"D:\Tmp\test1.xml")

Wednesday, May 25, 2011

Create Open XML Spreadsheet in F#

I also created a spreadsheet with the Open XML SDK and F# and posted the snippet at fssnip.net.

1: //reference to the Open Office SDK

2: #r @"C:\Program Files (x86)\Open XML SDK\V2.0\lib\DocumentFormat.OpenXml.dll"

3: //reference to the package

4: #r "WindowsBase"

6: open DocumentFormat.OpenXml

7: open DocumentFormat.OpenXml.Packaging

8: open DocumentFormat.OpenXml.Spreadsheet

10: let createSpreadsheet (filepath:string) (sheetName:string) =

11: // Create a spreadsheet document by supplying the filepath.

12: // By default, AutoSave = true, Editable = true, and Type = xlsx.

13:

14: using (SpreadsheetDocument.Create(filepath, SpreadsheetDocumentType.Workbook)) (fun spreadsheetDocument ->

15:

16: // Add a WorkbookPart to the document.

17: let workbookpart = spreadsheetDocument.AddWorkbookPart()

18: workbookpart.Workbook <- new Workbook()

19:

20: // Add a WorksheetPart to the WorkbookPart.

21: // http://stackoverflow.com/questions/5702939/unable-to-append-a-sheet-using-openxml-with-f-fsharp

22: let worksheetPart = workbookpart.AddNewPart<WorksheetPart>()

23: worksheetPart.Worksheet <- new Worksheet(new SheetData():> OpenXmlElement)

24:

25: // Add Sheets to the Workbook.

26: let sheets = spreadsheetDocument.WorkbookPart.Workbook.AppendChild<Sheets>(new Sheets())

27:

28: // Append a new worksheet and associate it with the workbook.

29: let sheet = new Sheet()

30: sheet.Id <- StringValue(spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart))

31: sheet.SheetId <- UInt32Value(1u)

32: sheet.Name <- StringValue(sheetName)

33: sheets.Append([sheet :> OpenXmlElement])

34: )

35:

36: let result = createSpreadsheet @"D:\Tmp\test1.xlsx" "test";;

37:

I thought that it would be as straightforward as creating a word document. This was not the case.

This time some objects have be up casted (the :> symbol) to OpenXmlElement objects and some values had to be transfomed form strings to StringValues.

The source: http://stackoverflow.com/questions/5702939/unable-to-append-a-sheet-using-openxml-with-f-fsharp.

Tuesday, May 24, 2011

Create Open XML Word document in F#

I needed a word document. I created it with the Open XML SDK and F# and posted the snippet at fssnip.net.

1: //reference to the Open Office SDK

2: #r @"C:\Program Files (x86)\Open XML SDK\V2.0\lib\DocumentFormat.OpenXml.dll"

3: //reference to the package

4: #r "WindowsBase"

6: open DocumentFormat.OpenXml

7: open DocumentFormat.OpenXml.Wordprocessing

8: open DocumentFormat.OpenXml.Packaging

10: let testString = "This is a test"

11: let printXml text =

12: printfn "xml: %s" text

13:

14: let createBody (text:string) =

15: let text = new Text(text)

16: let run = new Run()

17: run.AppendChild(text) |> ignore

18: let para = new Paragraph()

19: para.AppendChild(run)|> ignore

20: let body = new Body()

21: body.AppendChild(para)|> ignore

22: body

23:

24: printXml (createBody testString).InnerXml

25:

26: let createDocument (text:string) =

27: let body = createBody text

28: let doc = new Document()

29: doc.AppendChild(body) |> ignore

30: doc

31:

32: printXml (createDocument testString).InnerXml

33:

34: let createWordprocessingDocument (filepath:string) text=

35: using (WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document)) (fun doc ->

36: let mainPart = doc.AddMainDocumentPart();

37: mainPart.Document <- createDocument text

38: )

39:

40: let result3 = createWordprocessingDocument @"D:\Tmp\test1.docx" testString

It is a direct transformation of the C# code from the help file of the Open XML SDK:

public static void CreateWordprocessingDocument(string filepath)

    // Create a document by supplying the filepath.

    using (WordprocessingDocument wordDocument =

        WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document))

        // Add a main document part.

        MainDocumentPart mainPart = wordDocument.AddMainDocumentPart();

        // Create the document structure and add some text.

        mainPart.Document = new Document();

        Body body = mainPart.Document.AppendChild(new Body());

        Paragraph para = body.AppendChild(new Paragraph());

        Run run = para.AppendChild(new Run());

        run.AppendChild(new Text("Create text in body - CreateWordprocessingDocument"));