Open XML SDK for Office

https://learn.microsoft.com/en-us/office/open-xml
Admin
The Open XML SDK for Office is a Microsoft SDK that provides strongly-typed classes to...
Tokens:243,876
Snippets:1,612
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Call AddHeaderFromTo Method

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-replace-the-header-in-a-word-processing-document

Example of how to invoke the AddHeaderFromTo method using file paths from command line arguments.

```C#
string fromFile = args[0];
string toFile = args[1];

AddHeaderFromTo(fromFile, toFile);
```

```VB
Dim fromFile As String = args(0)
Dim toFile As String = args(1)

AddHeaderFromTo(fromFile, toFile)
```

--------------------------------

### Call AddNewPart Method

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-add-a-new-document-part-to-a-package

Example of invoking the AddNewPart method using command line arguments.

```csharp
string document = args[0];
string fileName = args[1];

AddNewPart(args[0], args[1]);
```

```vb
Dim document As String = args(0)
Dim fileName As String = args(1)

AddNewPart(document, fileName)
```

--------------------------------

### WordprocessingML Comment Element Example

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-retrieve-comments-from-a-word-processing-document

Example of a single comment element with an ID and initials attribute.

```XML
    <w:comment w:id="1" w:initials="User">
      …
    </w:comment>
```

--------------------------------

### Create Presentation Document and Parts in VB

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-create-a-presentation-document-by-providing-a-file-name

Demonstrates how to create a new presentation document at a specified file path and initialize its required parts.

```vb
Sub CreatePresentation(filepath As String)
    ' Create a presentation at a specified file path. The presentation document type is pptx, by default.
    Using presentationDoc As PresentationDocument = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation)
        Dim presentationPart As PresentationPart = presentationDoc.AddPresentationPart()
        presentationPart.Presentation = New Presentation()

        CreatePresentationParts(presentationPart)
    End Using
End Sub

Sub CreatePresentationParts(presentationPart As PresentationPart)
    Dim slideMasterIdList1 As New SlideMasterIdList(New SlideMasterId() With {.Id = CType(2147483648UI, UInt32Value), .RelationshipId = "rId1"})
    Dim slideIdList1 As New SlideIdList(New SlideId() With {.Id = CType(256UI, UInt32Value), .RelationshipId = "rId2"})
    Dim slideSize1 As New SlideSize() With {.Cx = 9144000, .Cy = 6858000, .Type = SlideSizeValues.Screen4x3}
    Dim notesSize1 As New NotesSize() With {.Cx = 6858000, .Cy = 9144000}
    Dim defaultTextStyle1 As New DefaultTextStyle()

    presentationPart.Presentation.Append(slideMasterIdList1, slideIdList1, slideSize1, notesSize1, defaultTextStyle1)

    Dim slidePart1 As SlidePart
    Dim slideLayoutPart1 As SlideLayoutPart
    Dim slideMasterPart1 As SlideMasterPart
    Dim themePart1 As ThemePart
```

--------------------------------

### Initialize Presentation Parts

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-create-a-presentation-document-by-providing-a-file-name

This snippet demonstrates the sequence of creating and linking slide parts, layout parts, master parts, and themes within a presentation document.

```vbnet
    slidePart1 = CreateSlidePart(presentationPart)
    slideLayoutPart1 = CreateSlideLayoutPart(slidePart1)
    slideMasterPart1 = CreateSlideMasterPart(slideLayoutPart1)
    themePart1 = CreateTheme(slideMasterPart1)

    slideMasterPart1.AddPart(slideLayoutPart1, "rId1")
    presentationPart.AddPart(slideMasterPart1, "rId1")
    presentationPart.AddPart(themePart1, "rId5")
End Sub
```

--------------------------------

### Generated SpreadsheetML Examples

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/working-with-the-shared-string-table

Example XML output for the shared strings table and the corresponding worksheet data after inserting text.

```xml
    <?xml version="1.0" encoding="utf-8"?>
    <x:sst xmlns:x="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
      <x:si>
        <x:t>hello</x:t>
      </x:si>
    </x:sst>
```

```xml
    <?xml version="1.0" encoding="utf-8"?>
    <x:worksheet xmlns:x="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
      <x:sheetData>
        <x:row r="1">
          <x:c r="A1" t="s">
            <x:v>0</x:v>
          </x:c>
        </x:row>
      </x:sheetData>
    </x:worksheet>
```

--------------------------------

### Create a Presentation Document with Open XML SDK

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/working-with-presentations

Initializes a new presentation document at a specified file path and populates it with required presentation parts.

```csharp
static void CreatePresentation(string filepath)
{
    // Create a presentation at a specified file path. The presentation document type is pptx, by default.
    using (PresentationDocument presentationDoc = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation))
    {
        PresentationPart presentationPart = presentationDoc.AddPresentationPart();
        presentationPart.Presentation = new Presentation();

        CreatePresentationParts(presentationPart);
    }
}

static void CreatePresentationParts(PresentationPart presentationPart)
{
    SlideMasterIdList slideMasterIdList1 = new SlideMasterIdList(new SlideMasterId() { Id = (UInt32Value)2147483648U, RelationshipId = "rId1" });
    SlideIdList slideIdList1 = new SlideIdList(new SlideId() { Id = (UInt32Value)256U, RelationshipId = "rId2" });
    SlideSize slideSize1 = new SlideSize() { Cx = 9144000, Cy = 6858000, Type = SlideSizeValues.Screen4x3 };
    NotesSize notesSize1 = new NotesSize() { Cx = 6858000, Cy = 9144000 };
    DefaultTextStyle defaultTextStyle1 = new DefaultTextStyle();

    presentationPart.Presentation.Append(slideMasterIdList1, slideIdList1, slideSize1, notesSize1, defaultTextStyle1);

    SlidePart slidePart1;
    SlideLayoutPart slideLayoutPart1;
    SlideMasterPart slideMasterPart1;
    ThemePart themePart1;


    slidePart1 = CreateSlidePart(presentationPart);
    slideLayoutPart1 = CreateSlideLayoutPart(slidePart1);
    string slideLayoutPart1RelId = slidePart1.GetIdOfPart(slideLayoutPart1);
    slideMasterPart1 = CreateSlideMasterPart(slideLayoutPart1);
    themePart1 = CreateTheme(slideMasterPart1);

    slideMasterPart1.AddPart(slideLayoutPart1, "rId1");
    presentationPart.AddPart(slideMasterPart1, "rId1");
    presentationPart.AddPart(themePart1, "rId5");
}
```

```vb
Sub CreatePresentation(filepath As String)
    ' Create a presentation at a specified file path. The presentation document type is pptx, by default.
    Using presentationDoc As PresentationDocument = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation)
        Dim presentationPart As PresentationPart = presentationDoc.AddPresentationPart()
        presentationPart.Presentation = New Presentation()

        CreatePresentationParts(presentationPart)
    End Using
End Sub

Sub CreatePresentationParts(presentationPart As PresentationPart)
    Dim slideMasterIdList1 As New SlideMasterIdList(New SlideMasterId() With {.Id = CType(2147483648UI, UInt32Value), .RelationshipId = "rId1"})
    Dim slideIdList1 As New SlideIdList(New SlideId() With {.Id = CType(256UI, UInt32Value), .RelationshipId = "rId2"})
    Dim slideSize1 As New SlideSize() With {.Cx = 9144000, .Cy = 6858000, .Type = SlideSizeValues.Screen4x3}
    Dim notesSize1 As New NotesSize() With {.Cx = 6858000, .Cy = 9144000}
    Dim defaultTextStyle1 As New DefaultTextStyle()

    presentationPart.Presentation.Append(slideMasterIdList1, slideIdList1, slideSize1, notesSize1, defaultTextStyle1)

    Dim slidePart1 As SlidePart
    Dim slideLayoutPart1 As SlideLayoutPart
    Dim slideMasterPart1 As SlideMasterPart
    Dim themePart1 As ThemePart

    slidePart1 = CreateSlidePart(presentationPart)
    slideLayoutPart1 = CreateSlideLayoutPart(slidePart1)
    slideMasterPart1 = CreateSlideMasterPart(slideLayoutPart1)
    themePart1 = CreateTheme(slideMasterPart1)

    slideMasterPart1.AddPart(slideLayoutPart1, "rId1")
    presentationPart.AddPart(slideMasterPart1, "rId1")
    presentationPart.AddPart(themePart1, "rId5")
End Sub
```

--------------------------------

### Get SharedStringTablePart

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/how-to-retrieve-the-values-of-cells-in-a-spreadsheet

Retrieves the SharedStringTablePart from the workbook part.

```csharp
// For shared strings, look up the value in the
// shared strings table.
var stringTable = wbPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
```

```vb
' For shared strings, look up the value in the
' shared strings table.
Dim stringTable = wbPart.GetPartsOfType(Of SharedStringTablePart)().FirstOrDefault()
```

--------------------------------

### Example XML Cell Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/how-to-retrieve-the-values-of-cells-in-a-spreadsheet

The XML structure of a cell containing a numeric value.

```xml
    <x:c r="A1">
        <x:v>12.345000000000001</x:v>
    </x:c>
```

--------------------------------

### Initialize Document and Styles Part Reference

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-replace-the-styles-parts-in-a-word-processing-document

Opens a Word document for write access and initializes the reference to the styles part.

```C#
// Open the document for write access and get a reference.
using (var document = WordprocessingDocument.Open(fileName, true))
{
    if (document.MainDocumentPart is null || (document.MainDocumentPart.StyleDefinitionsPart is null && document.MainDocumentPart.StylesWithEffectsPart is null))
    {
        throw new ArgumentNullException("MainDocumentPart and/or one or both of the Styles parts is null.");
    }

    // Get a reference to the main document part.
    var docPart = document.MainDocumentPart;

    // Assign a reference to the appropriate part to the
    // stylesPart variable.

    StylesPart? stylesPart = null;
```

```VB
' Open the document for write access and get a reference.
Using document As WordprocessingDocument = WordprocessingDocument.Open(fileName, True)
    If document.MainDocumentPart Is Nothing OrElse (document.MainDocumentPart.StyleDefinitionsPart Is Nothing AndAlso document.MainDocumentPart.StylesWithEffectsPart Is Nothing) Then
        Throw New ArgumentNullException("MainDocumentPart and/or one or both of the Styles parts is null.")
    End If

    ' Get a reference to the main document part.
    Dim docPart = document.MainDocumentPart

    ' Assign a reference to the appropriate part to the
    ' stylesPart variable.

    Dim stylesPart As StylesPart = Nothing
```

--------------------------------

### SpreadsheetML Workbook Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/how-to-get-worksheet-information-from-a-package

Example of the XML structure for a workbook containing two worksheets.

```xml
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> 
    <workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
        <sheets>
            <sheet name="MySheet1" sheetId="1" r:id="rId1" /> 
            <sheet name="MySheet2" sheetId="2" r:id="rId2" /> 
        </sheets>
    </workbook>
```

--------------------------------

### Embed Video and Configure Properties in Presentation

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-add-a-video-to-a-slide-in-a-presentation

Demonstrates how to create a media data part, feed the video stream, and set up the necessary non-visual drawing properties for a video element.

```csharp
 // Create video Media Data Part (content type, extension)
 MediaDataPart mediaDataPart = presentationDocument.CreateMediaDataPart("video/mp4", ".mp4");

 //Get the video file and feed the stream
 using (Stream mediaDataPartStream = File.OpenRead(videoFilePath))
 {
     mediaDataPart.FeedData(mediaDataPartStream);
 }
 //Adds a VideoReferenceRelationship to the MainDocumentPart
 slidePart.AddVideoReferenceRelationship(mediaDataPart, embedId);

 //Adds a MediaReferenceRelationship to the SlideLayoutPart
 slidePart.AddMediaReferenceRelationship(mediaDataPart, mediaEmbedId);

 NonVisualDrawingProperties nonVisualDrawingProperties = new NonVisualDrawingProperties() { Id = shapeId, Name = "video" };
 A.VideoFromFile videoFromFile = new A.VideoFromFile() { Link = embedId };

 ApplicationNonVisualDrawingProperties appNonVisualDrawingProperties = new ApplicationNonVisualDrawingProperties();
 appNonVisualDrawingProperties.Append(videoFromFile);

 //adds sample image to the slide with id to be used as reference in blip
 ImagePart imagePart = slidePart.AddImagePart(ImagePartType.Png, imgEmbedId);
 using (Stream data = File.OpenRead(coverPicPath))
 {
     imagePart.FeedData(data);
 }

 if (slidePart!.Slide!.CommonSlideData!.ShapeTree == null)
 {
     throw new NullReferenceException("Presentation shape tree is empty");
 }

 //Getting existing shape tree object from PowerPoint
 ShapeTree shapeTree = slidePart.Slide.CommonSlideData.ShapeTree;

 // specifies the existence of a picture within a presentation.
 // It can have non-visual properties, a picture fill as well as shape properties attached to it.
 Picture picture = new Picture();
 NonVisualPictureProperties nonVisualPictureProperties = new NonVisualPictureProperties();

 A.HyperlinkOnClick hyperlinkOnClick = new A.HyperlinkOnClick() { Id = "", Action = "ppaction://media" };
 nonVisualDrawingProperties.Append(hyperlinkOnClick);

 NonVisualPictureDrawingProperties nonVisualPictureDrawingProperties = new NonVisualPictureDrawingProperties();
 A.PictureLocks pictureLocks = new A.PictureLocks() { NoChangeAspect = true };
 nonVisualPictureDrawingProperties.Append(pictureLocks);

 ApplicationNonVisualDrawingPropertiesExtensionList appNonVisualDrawingPropertiesExtensionList = new ApplicationNonVisualDrawingPropertiesExtensionList();
 ApplicationNonVisualDrawingPropertiesExtension appNonVisualDrawingPropertiesExtension = new ApplicationNonVisualDrawingPropertiesExtension() { Uri = "{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}" };
```

```vb
' Create video Media Data Part (content type, extension)
Dim mediaDataPart As MediaDataPart = presentationDocument.CreateMediaDataPart("video/mp4", ".mp4")

' Get the video file and feed the stream
Using mediaDataPartStream As Stream = File.OpenRead(videoFilePath)
    mediaDataPart.FeedData(mediaDataPartStream)
End Using

' Adds a VideoReferenceRelationship to the MainDocumentPart
slidePart.AddVideoReferenceRelationship(mediaDataPart, embedId)

' Adds a MediaReferenceRelationship to the SlideLayoutPart
slidePart.AddMediaReferenceRelationship(mediaDataPart, mediaEmbedId)

Dim nonVisualDrawingProperties As New NonVisualDrawingProperties() With {
    .Id = shapeId,
    .Name = "video"
}
Dim videoFromFile As New A.VideoFromFile() With {
    .Link = embedId
}

Dim appNonVisualDrawingProperties As New ApplicationNonVisualDrawingProperties()
appNonVisualDrawingProperties.Append(videoFromFile)

' Adds sample image to the slide with id to be used as reference in blip
Dim imagePart As ImagePart = slidePart.AddImagePart(ImagePartType.Png, imgEmbedId)
Using data As Stream = File.OpenRead(coverPicPath)
    imagePart.FeedData(data)
End Using

If slidePart.Slide.CommonSlideData.ShapeTree Is Nothing Then
    Throw New NullReferenceException("Presentation shape tree is empty")
End If

' Getting existing shape tree object from PowerPoint
Dim shapeTree As ShapeTree = slidePart.Slide.CommonSlideData.ShapeTree

' Specifies the existence of a picture within a presentation
Dim picture As New Picture()
Dim nonVisualPictureProperties As New NonVisualPictureProperties()

Dim hyperlinkOnClick As New A.HyperlinkOnClick() With {
    .Id = "",
    .Action = "ppaction://media"
}
nonVisualDrawingProperties.Append(hyperlinkOnClick)

Dim nonVisualPictureDrawingProperties As New NonVisualPictureDrawingProperties()
Dim pictureLocks As New A.PictureLocks() With {
    .NoChangeAspect = True
}
nonVisualPictureDrawingProperties.Append(pictureLocks)

Dim appNonVisualDrawingPropertiesExtensionList As New ApplicationNonVisualDrawingPropertiesExtensionList()
Dim appNonVisualDrawingPropertiesExtension As New ApplicationNonVisualDrawingPropertiesExtension() With {
    .Uri = "{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}"
}
```

--------------------------------

### Create a Presentation Document

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-create-a-presentation-document-by-providing-a-file-name

Initializes a new presentation document at a specified file path and adds the necessary presentation part.

```C#
static void CreatePresentation(string filepath)
{
    // Create a presentation at a specified file path. The presentation document type is pptx, by default.
    using (PresentationDocument presentationDoc = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation))
    {
        PresentationPart presentationPart = presentationDoc.AddPresentationPart();
        presentationPart.Presentation = new Presentation();

        CreatePresentationParts(presentationPart);
    }
}
```

```VB
Sub CreatePresentation(filepath As String)
    ' Create a presentation at a specified file path. The presentation document type is pptx, by default.
    Using presentationDoc As PresentationDocument = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation)
        Dim presentationPart As PresentationPart = presentationDoc.AddPresentationPart()
        presentationPart.Presentation = New Presentation()

        CreatePresentationParts(presentationPart)
    End Using
End Sub
```

--------------------------------

### Retrieve Properties Reference

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-set-a-custom-property-in-a-word-processing-document

Gets a reference to the properties collection and verifies it is not null before proceeding.

```C#
var props = customProps.Properties;

if (props is not null)
{
```

```VB
Dim props = customProps.Properties

If props IsNot Nothing Then
```

--------------------------------

### Create a minimum blank workbook using Open XML SDK

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/structure-of-a-spreadsheetml-document

Demonstrates the creation of a basic spreadsheet document with a single worksheet using the Open XML SDK.

```C#
static void CreateSpreadsheetWorkbook(string filepath)
{
    // Create a spreadsheet document by supplying the filepath.
    // By default, AutoSave = true, Editable = true, and Type = xlsx.
    using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(filepath, SpreadsheetDocumentType.Workbook))
    {
        // Add a WorkbookPart to the document.
        WorkbookPart workbookPart = spreadsheetDocument.AddWorkbookPart();
        workbookPart.Workbook = new Workbook();

        // Add a WorksheetPart to the WorkbookPart.
        WorksheetPart worksheetPart = workbookPart.AddNewPart<WorksheetPart>();
        worksheetPart.Worksheet = new Worksheet(new SheetData());

        // Add Sheets to the Workbook.
        Sheets sheets = workbookPart.Workbook.AppendChild(new Sheets());

        // Append a new worksheet and associate it with the workbook.
        Sheet sheet = new Sheet() { Id = workbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "mySheet" };
        sheets.Append(sheet);
    }
}
```

```VB
Sub CreateSpreadsheetWorkbook(filepath As String)
    ' Create a spreadsheet document by supplying the filepath.
    ' By default, AutoSave = true, Editable = true, and Type = xlsx.
    Using spreadsheetDocument As SpreadsheetDocument = SpreadsheetDocument.Create(filepath, SpreadsheetDocumentType.Workbook)
        ' Add a WorkbookPart to the document.
        Dim workbookPart As WorkbookPart = spreadsheetDocument.AddWorkbookPart()
        workbookPart.Workbook = New Workbook()

        ' Add a WorksheetPart to the WorkbookPart.
        Dim worksheetPart As WorksheetPart = workbookPart.AddNewPart(Of WorksheetPart)()
        worksheetPart.Worksheet = New Worksheet(New SheetData())

        ' Add Sheets to the Workbook.
        Dim sheets As Sheets = workbookPart.Workbook.AppendChild(Of Sheets)(New Sheets())

        ' Append a new worksheet and associate it with the workbook.
        Dim sheet As Sheet = New Sheet() With {
            .Id = workbookPart.GetIdOfPart(worksheetPart),
            .SheetId = 1,
            .Name = "mySheet"
        }
        sheets.Append(sheet)
    End Using
End Sub
```

--------------------------------

### Invoke ReplaceStyles Method

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-replace-the-styles-parts-in-a-word-processing-document

Example of calling the ReplaceStyles method with file paths provided as arguments.

```C#
string fromDoc = args[0];
string toDoc = args[1];

ReplaceStyles(fromDoc, toDoc);
```

```VB
Dim fromDoc As String = args(0)
Dim toDoc As String = args(1)

ReplaceStyles(fromDoc, toDoc)
```

--------------------------------

### Create a Presentation Document in C#

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-create-a-presentation-document-by-providing-a-file-name

Uses the Open XML SDK to create a new .pptx file and populate it with essential parts such as slide masters and layouts.

```csharp
static void CreatePresentation(string filepath)
{
    // Create a presentation at a specified file path. The presentation document type is pptx, by default.
    using (PresentationDocument presentationDoc = PresentationDocument.Create(filepath, PresentationDocumentType.Presentation))
    {
        PresentationPart presentationPart = presentationDoc.AddPresentationPart();
        presentationPart.Presentation = new Presentation();

        CreatePresentationParts(presentationPart);
    }
}

static void CreatePresentationParts(PresentationPart presentationPart)
{
    SlideMasterIdList slideMasterIdList1 = new SlideMasterIdList(new SlideMasterId() { Id = (UInt32Value)2147483648U, RelationshipId = "rId1" });
    SlideIdList slideIdList1 = new SlideIdList(new SlideId() { Id = (UInt32Value)256U, RelationshipId = "rId2" });
    SlideSize slideSize1 = new SlideSize() { Cx = 9144000, Cy = 6858000, Type = SlideSizeValues.Screen4x3 };
    NotesSize notesSize1 = new NotesSize() { Cx = 6858000, Cy = 9144000 };
    DefaultTextStyle defaultTextStyle1 = new DefaultTextStyle();

    presentationPart.Presentation.Append(slideMasterIdList1, slideIdList1, slideSize1, notesSize1, defaultTextStyle1);

    SlidePart slidePart1;
    SlideLayoutPart slideLayoutPart1;
    SlideMasterPart slideMasterPart1;
    ThemePart themePart1;


    slidePart1 = CreateSlidePart(presentationPart);
    slideLayoutPart1 = CreateSlideLayoutPart(slidePart1);
    string slideLayoutPart1RelId = slidePart1.GetIdOfPart(slideLayoutPart1);
    slideMasterPart1 = CreateSlideMasterPart(slideLayoutPart1);
    themePart1 = CreateTheme(slideMasterPart1);

    slideMasterPart1.AddPart(slideLayoutPart1, "rId1");
    presentationPart.AddPart(slideMasterPart1, "rId1");
    presentationPart.AddPart(themePart1, "rId5");
}
static SlidePart CreateSlidePart(PresentationPart presentationPart)
{
    SlidePart slidePart1 = presentationPart.AddNewPart<SlidePart>("rId2");
    slidePart1.Slide = new Slide(
            new CommonSlideData(
                new ShapeTree(
                    new P.NonVisualGroupShapeProperties(
                        new P.NonVisualDrawingProperties() { Id = (UInt32Value)1U, Name = "" },
                        new P.NonVisualGroupShapeDrawingProperties(),
                        new ApplicationNonVisualDrawingProperties()),
                    new GroupShapeProperties(new TransformGroup()),
                    new P.Shape(
                        new P.NonVisualShapeProperties(
                            new P.NonVisualDrawingProperties() { Id = (UInt32Value)2U, Name = "Title 1" },
                            new P.NonVisualShapeDrawingProperties(new ShapeLocks() { NoGrouping = true }),
                            new ApplicationNonVisualDrawingProperties(new PlaceholderShape())),
                        new P.ShapeProperties(),
                        new P.TextBody(
                            new BodyProperties(),
                            new ListStyle(),
                            new Paragraph(new EndParagraphRunProperties() { Language = "en-US" }))))),
            new ColorMapOverride(new MasterColorMapping()));
    return slidePart1;
}

static SlideLayoutPart CreateSlideLayoutPart(SlidePart slidePart1)
{
    SlideLayoutPart slideLayoutPart1 = slidePart1.AddNewPart<SlideLayoutPart>();
    SlideLayout slideLayout = new SlideLayout(
    new CommonSlideData(new ShapeTree(
      new P.NonVisualGroupShapeProperties(
      new P.NonVisualDrawingProperties() { Id = (UInt32Value)1U, Name = "" },
      new P.NonVisualGroupShapeDrawingProperties(),
      new ApplicationNonVisualDrawingProperties()),
      new GroupShapeProperties(new TransformGroup()),
      new P.Shape(
      new P.NonVisualShapeProperties(
        new P.NonVisualDrawingProperties() { Id = (UInt32Value)2U, Name = "" },
        new P.NonVisualShapeDrawingProperties(new ShapeLocks() { NoGrouping = true }),
        new ApplicationNonVisualDrawingProperties(new PlaceholderShape())),
      new P.ShapeProperties(),
      new P.TextBody(
        new BodyProperties(),
        new ListStyle(),
        new Paragraph(new EndParagraphRunProperties()))))),
    new ColorMapOverride(new MasterColorMapping()));
    slideLayoutPart1.SlideLayout = slideLayout;
    return slideLayoutPart1;
}
```

--------------------------------

### SpreadsheetML Worksheet Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/how-to-get-worksheet-information-from-a-package

Example of the XML structure for a worksheet containing a single cell value.

```xml
    <?xml version="1.0" encoding="UTF-8" ?> 
    <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
        <sheetData>
            <row r="1">
                <c r="A1">
                    <v>100</v> 
                </c>
            </row>
        </sheetData>
    </worksheet>
```

--------------------------------

### Define a Slide Master in PresentationML

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/working-with-presentations

Example of a slide master specification within a presentation document.

```XML
<p:presentation xmlns:a="" xmlns:r="" xmlns:p=""
embedTrueTypeFonts="1">  
    …  
    <p:sldMasterIdLst>  
        <p:sldMasterId id="2147483648" r:id="rId1"/>  
    </p:sldMasterIdLst>  
    …  
</p:presentation>
```

--------------------------------

### Initialize Theme Part in Open XML

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/working-with-notes-slides

Checks if a theme part exists and initializes it with a default Office2 theme configuration if missing.

```vbnet
' Add the Theme if it is missing
    If themePart.Theme Is Nothing Then
        themePart.Theme = New Theme(
        New ThemeElements(
            New ColorScheme(
                New Dark1Color(
                    New SystemColor() With {.Val = SystemColorValues.WindowText}),
                New Light1Color(
                    New SystemColor() With {.Val = SystemColorValues.Window}),
                New Dark2Color(
                    New RgbColorModelHex() With {.Val = "f1d7be"}),
                New Light2Color(
                    New RgbColorModelHex() With {.Val = "171717"}),
                New Accent1Color(
                    New RgbColorModelHex() With {.Val = "ea9f7d"}),
                New Accent2Color(
                    New RgbColorModelHex() With {.Val = "168ecd"}),
                New Accent3Color(
                    New RgbColorModelHex() With {.Val = "e694db"}),
                New Accent4Color(
                    New RgbColorModelHex() With {.Val = "f0612a"}),
                New Accent5Color(
                    New RgbColorModelHex() With {.Val = "5fd46c"}),
                New Accent6Color(
                    New RgbColorModelHex() With {.Val = "b158d1"}),
                New D.Hyperlink(
                    New RgbColorModelHex() With {.Val = "699f82"}),
                New FollowedHyperlinkColor(
                    New RgbColorModelHex() With {.Val = "699f82"})) With {.Name = "Office2"},
            New D.FontScheme(
                New MajorFont(
                    New LatinFont(),
                    New EastAsianFont(),
                    New ComplexScriptFont()),
                New MinorFont(
                    New LatinFont(),
                    New EastAsianFont(),
                    New ComplexScriptFont())) With {.Name = "Office2"},
            New FormatScheme(
                New FillStyleList(
                    New NoFill(),
                    New SolidFill(),
                    New D.GradientFill(),
                    New D.BlipFill(),
                    New D.PatternFill(),
                    New GroupFill()),
                New LineStyleList(
                    New D.Outline(),
                    New D.Outline(),
                    New D.Outline()),
                New EffectStyleList(
                    New EffectStyle(
                        New EffectList()),
                    New EffectStyle(
                        New EffectList()),
                    New EffectStyle(
                        New EffectList())),
                New BackgroundFillStyleList(
                    New NoFill(),
                    New SolidFill(),
                    New D.GradientFill(),
                    New D.BlipFill(),
                    New D.PatternFill(),
                    New GroupFill())) With {.Name = "Office2"}),
        New ObjectDefaults(),
        New ExtraColorSchemeList())
    End If
End Using
```

--------------------------------

### Create Presentation Document Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-create-a-presentation-document-by-providing-a-file-name

Initializes the theme part for a presentation document.

```vbnet
    themePart1.Theme = theme1
    Return themePart1
End Function
```

--------------------------------

### XML Fragment for Document Settings

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-remove-a-document-part-from-a-package

Example of the settings element structure within a WordprocessingML document.

```XML
    <w:settings>
      <w:defaultTabStop w:val="720" />
      <w:characterSpacingControl w:val="dontCompress" />
    </w:settings>
```

--------------------------------

### Initialize OpenXmlReader and OpenXmlWriter

Source: https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/how-to-copy-a-worksheet-with-sax

Set up the reader for the source worksheet and the writer for the destination worksheet.

```C#
using (OpenXmlReader reader = OpenXmlPartReader.Create(worksheetPart))
using (OpenXmlWriter writer = OpenXmlPartWriter.Create(newWorksheetPart))
```

```VB
Using reader As OpenXmlReader = OpenXmlPartReader.Create(worksheetPart)
    Using writer As OpenXmlWriter = OpenXmlPartWriter.Create(newWorksheetPart)
```

--------------------------------

### WordprocessingML Markup for Paragraph Property Revision

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-accept-all-revisions-in-a-word-processing-document

Example of a centered paragraph property revision tracked with pPrChange.

```XML
    <w:pPr>
      <w:jc w:val="center"/>
      <w:pPrChange w:id="0" w:date="01-01-2006T12:00:00" w:author="Samantha Smith">
        <w:pPr/>
      </w:pPrChange>
    </w:pPr>
```

--------------------------------

### Define Slide Content Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/structure-of-a-presentationml-document

Example of the root <sld/> element structure for a slide XML file.

```XML
<p:sld xmlns:p="…">  
    <p:cSld name="">  
        …  
    </p:cSld>  
    <p:clrMapOvr>  
        …  
    </p:clrMapOvr>  
    <p:timing>  
        <p:tnLst>  
            <p:par>  
                <p:cTn id="1" dur="indefinite" restart="never"
nodeType="tmRoot"/>  
            </p:par>  
        </p:tnLst>  
    </p:timing>  
</p:sld>
```

--------------------------------

### Apply a Paragraph Style using Open XML SDK

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-create-and-add-a-paragraph-style-to-a-word-processing-document

Demonstrates opening a document, ensuring the StyleDefinitionsPart exists, creating a new style, and applying it to a paragraph.

```C#
string strDoc = args[0];

using (WordprocessingDocument doc = WordprocessingDocument.Open(strDoc, true))
{
    if (doc is null)
    {
        throw new ArgumentNullException("document could not be opened");
    }

    MainDocumentPart mainDocumentPart = doc.MainDocumentPart ?? doc.AddMainDocumentPart();

    // Get the Styles part for this document.
    StyleDefinitionsPart? part = mainDocumentPart.StyleDefinitionsPart;

    // If the Styles part does not exist, add it and then add the style.
    if (part is null)
    {
        part = AddStylesPartToPackage(doc);
    }

    // Set up a variable to hold the style ID.
    string parastyleid = "OverdueAmountPara";

    // Create and add a paragraph style to the specified styles part 
    // with the specified style ID, style name and aliases.
    CreateAndAddParagraphStyle(part, parastyleid, "Overdue Amount Para", "Late Due, Late Amount");

    // Add a paragraph with a run and some text.
    Paragraph p =
        new Paragraph(
            new Run(
                new Text("This is some text in a run in a paragraph.")));

    // Add the paragraph as a child element of the w:body element.
    mainDocumentPart.Document ??= new Document();
    mainDocumentPart.Document.Body ??= new Body();

    mainDocumentPart.Document.Body.AppendChild(p);

    // If the paragraph has no ParagraphProperties object, create one.
    if (p.Elements<ParagraphProperties>().Count() == 0)
    {
        p.PrependChild(new ParagraphProperties());
    }

    // Get a reference to the ParagraphProperties object.
    p.ParagraphProperties ??= new ParagraphProperties();
    ParagraphProperties pPr = p.ParagraphProperties;

    // If a ParagraphStyleId object doesn't exist, create one.
    pPr.ParagraphStyleId ??= new ParagraphStyleId();

    // Set the style of the paragraph.
    pPr.ParagraphStyleId.Val = parastyleid;
}
```

--------------------------------

### Insert a Table using Open XML SDK

Source: https://learn.microsoft.com/en-us/office/open-xml/word/how-to-insert-a-table-into-a-word-processing-document

This example demonstrates opening an existing Word document and appending a new table with dashed borders and sample cell content.

```vb
Imports DocumentFormat.OpenXml
Imports DocumentFormat.OpenXml.Packaging
Imports DocumentFormat.OpenXml.Wordprocessing
Imports BottomBorder = DocumentFormat.OpenXml.Wordprocessing.BottomBorder
Imports LeftBorder = DocumentFormat.OpenXml.Wordprocessing.LeftBorder
Imports RightBorder = DocumentFormat.OpenXml.Wordprocessing.RightBorder
Imports Run = DocumentFormat.OpenXml.Wordprocessing.Run
Imports Table = DocumentFormat.OpenXml.Wordprocessing.Table
Imports Text = DocumentFormat.OpenXml.Wordprocessing.Text
Imports TopBorder = DocumentFormat.OpenXml.Wordprocessing.TopBorder

Module MyModule

    Sub Main(args As String())
        Dim filePath As String = args(0)
        CreateTable(filePath)
    End Sub


    ' Insert a table into a word processing document.
    Public Sub CreateTable(ByVal fileName As String)
        ' Use the file name and path passed in as an argument 
        ' to open an existing Word 2007 document.

        Using doc As WordprocessingDocument = WordprocessingDocument.Open(fileName, True)

            ' Create an empty table.
            Dim table As New Table()

            ' Create a TableProperties object and specify its border information.
            Dim tblProp As New TableProperties(New TableBorders(
            New TopBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                },
            New BottomBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                },
            New LeftBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                },
            New RightBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                },
            New InsideHorizontalBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                },
            New InsideVerticalBorder() With
                {
                    .Val = New EnumValue(Of BorderValues)(BorderValues.Dashed),
                    .Size = 24
                })
            )
            ' Append the TableProperties object to the empty table.
            table.AppendChild(Of TableProperties)(tblProp)

            ' Create a row.
            Dim tr As New TableRow()

            ' Create a cell.
            Dim tc1 As New TableCell()

            ' Specify the width property of the table cell.
            tc1.Append(New TableCellProperties(New TableCellWidth()))

            ' Specify the table cell content.
            tc1.Append(New Paragraph(New Run(New Text("some text"))))

            ' Append the table cell to the table row.
            tr.Append(tc1)

            ' Create a second table cell by copying the OuterXml value of the first table cell.
            Dim tc2 As New TableCell(tc1.OuterXml)

            ' Append the table cell to the table row.
            tr.Append(tc2)

            ' Append the table row to the table.
            table.Append(tr)

            ' Append the table to the document.
            doc.MainDocumentPart.Document.Body.Append(table)
        End Using
    End Sub
End Module
```

--------------------------------

### Define the sldLayout Root Element

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/structure-of-a-presentationml-document

Example of the sldLayout root element structure for a Slide Layout part.

```xml
<p:sldLayout xmlns:p="…" matchingName="" type="title" preserve="1">  
    <p:cSld name="Title Slide">  
        …  
    </p:cSld>  
    <p:clrMapOvr>  
        <a:masterClrMapping/>  
    </p:clrMapOvr>  
    <p:timing/>  
</p:sldLayout>
```

--------------------------------

### Define Slide IDs in PresentationML

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/working-with-presentations

Example of a slide ID list specification within a presentation document.

```XML
<p:presentation xmlns:a="" xmlns:r="" xmlns:p="" embedTrueTypeFonts="1">  
    …  
    <p:sldIdLst>  
        <p:sldId id="256" r:id="rId3"/>  
        <p:sldId id="257" r:id="rId4"/>  
        <p:sldId id="258" r:id="rId5"/>  
        <p:sldId id="259" r:id="rId6"/>  
        <p:sldId id="260" r:id="rId7"/>  
    </p:sldIdLst>  
    ...  
</p:presentation>
```

--------------------------------

### Create and Populate a Word Document Package

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-create-a-package

Initializes a new Word document package and writes WordprocessingML content to the main document part.

```csharp
// To create a new package as a Word document.
static void CreateNewWordDocument(string document)
{
    using (WordprocessingDocument wordDoc = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document))
    {
        // Set the content of the document so that Word can open it.
        MainDocumentPart mainPart = wordDoc.AddMainDocumentPart();

        SetMainDocumentContent(mainPart);
    }
}

// Set the content of MainDocumentPart.
static void SetMainDocumentContent(MainDocumentPart part)
{
    const string docXml = @"<?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>Hello World</w:t>
                                  </w:r>
                                </w:p>
                              </w:body>
                            </w:document>";

    using (Stream stream = part.GetStream())
    {
        byte[] buf = (new UTF8Encoding()).GetBytes(docXml);
        stream.Write(buf, 0, buf.Length);
    }
}
```

```vb
' To create a new package as a Word document.
Sub CreateNewWordDocument(document As String)
    Using wordDoc As WordprocessingDocument = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document)
        ' Set the content of the document so that Word can open it.
        Dim mainPart As MainDocumentPart = wordDoc.AddMainDocumentPart()

        SetMainDocumentContent(mainPart)
    End Using
End Sub

' Set the content of MainDocumentPart.
Sub SetMainDocumentContent(part As MainDocumentPart)
    Const docXml As String = "<?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>Hello World</w:t>" &
                             "</w:r>" &
                             "</w:p>" &
                             "</w:body>" &
                             "</w:document>"

    Using stream As Stream = part.GetStream()
        Dim buf As Byte() = (New UTF8Encoding()).GetBytes(docXml)
        stream.Write(buf, 0, buf.Length)
    End Using
End Sub
```

--------------------------------

### PresentationML Slide Shape Tree Structure

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/how-to-change-the-fill-color-of-a-shape-in-a-presentation

Example of the XML structure for a slide containing a shape tree.

```xml
    <p:sld>
      <p:cSld>
        <p:spTree>
          <p:nvGrpSpPr>
          ..
          </p:nvGrpSpPr>
          <p:grpSpPr>
          ..
          </p:grpSpPr>
          <p:sp>
          ..
          </p:sp>
        </p:spTree>
      </p:cSld>
      ..
    </p:sld>
```

--------------------------------

### Initialize a WordprocessingDocument

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-add-a-new-document-part-that-receives-a-relationship-id-to-a-package

Creates a new WordprocessingDocument instance at the specified file path.

```C#
static void AddNewPart(string document)
{
    // Create a new word processing document.
    using (WordprocessingDocument wordDoc = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document))
```

```VB
Sub AddNewPart(document As String)
    ' Create a new word processing document.
    Using wordDoc As WordprocessingDocument = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document)
```

--------------------------------

### Create a SlidePart and Slide instance

Source: https://learn.microsoft.com/en-us/office/open-xml/presentation/working-with-presentation-slides

Demonstrates adding a new slide part to a presentation and initializing the Slide object with its required child elements.

```C#
static SlidePart CreateSlidePart(PresentationPart presentationPart)
{
    SlidePart slidePart1 = presentationPart.AddNewPart<SlidePart>("rId2");
    slidePart1.Slide = new Slide(
            new CommonSlideData(
                new ShapeTree(
                    new P.NonVisualGroupShapeProperties(
                        new P.NonVisualDrawingProperties() { Id = (UInt32Value)1U, Name = "" },
                        new P.NonVisualGroupShapeDrawingProperties(),
                        new ApplicationNonVisualDrawingProperties()),
                    new GroupShapeProperties(new TransformGroup()),
                    new P.Shape(
                        new P.NonVisualShapeProperties(
                            new P.NonVisualDrawingProperties() { Id = (UInt32Value)2U, Name = "Title 1" },
                            new P.NonVisualShapeDrawingProperties(new ShapeLocks() { NoGrouping = true }),
                            new ApplicationNonVisualDrawingProperties(new PlaceholderShape())),
                        new P.ShapeProperties(),
                        new P.TextBody(
                            new BodyProperties(),
                            new ListStyle(),
                            new Paragraph(new EndParagraphRunProperties() { Language = "en-US" }))))),
            new ColorMapOverride(new MasterColorMapping()));
    return slidePart1;
}
```

```VB
Function CreateSlidePart(presentationPart As PresentationPart) As SlidePart
    Dim slidePart1 As SlidePart = presentationPart.AddNewPart(Of SlidePart)("rId2")
    Dim shape As New P.Shape(
                    New P.NonVisualShapeProperties(
                        New P.NonVisualDrawingProperties() With {.Id = CType(2UI, UInt32Value), .Name = "Title 1"},
                        New P.NonVisualShapeDrawingProperties(New ShapeLocks() With {.NoGrouping = True}),
                        New ApplicationNonVisualDrawingProperties(New PlaceholderShape())),
                    New P.ShapeProperties(),
                    New P.TextBody(
                        New BodyProperties(),
                        New ListStyle(),
                        New Paragraph(New EndParagraphRunProperties() With {.Language = "en-US"})))

    slidePart1.Slide = New Slide(
        New CommonSlideData(
            New ShapeTree(
                New P.NonVisualGroupShapeProperties(
                    New P.NonVisualDrawingProperties() With {.Id = CType(1UI, UInt32Value), .Name = ""},
                    New P.NonVisualGroupShapeDrawingProperties(),
                    New ApplicationNonVisualDrawingProperties()),
                New GroupShapeProperties(New TransformGroup(shape))),
        New ColorMapOverride(New MasterColorMapping())))
    Return slidePart1
End Function
```

--------------------------------

### Call CopyThemeContent Method

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-copy-the-contents-of-an-open-xml-package-part-to-a-document-part-in-a-dif

Example usage for invoking the CopyThemeContent method with file paths provided as arguments.

```csharp
string fromDocument1 = args[0];
string toDocument2 = args[1];

CopyThemeContent(fromDocument1, toDocument2);
```

```vb
Dim fromDocument1 As String = args(0)
Dim toDocument2 As String = args(1)

CopyThemeContent(fromDocument1, toDocument2)
```

--------------------------------

### Call the ReplaceTheme Method

Source: https://learn.microsoft.com/en-us/office/open-xml/general/how-to-replace-the-theme-part-in-a-word-processing-document

Example usage for invoking the ReplaceTheme method with document paths provided as arguments.

```C#
string document = args[0];
string themeFile = args[1];

ReplaceTheme(document, themeFile);
```

```VB
Dim document As String = args(0)
Dim themeFile As String = args(1)

ReplaceTheme(document, themeFile)
```

--------------------------------

### Create a Minimal WordprocessingML Document with Open XML SDK

Source: https://learn.microsoft.com/en-us/office/open-xml/word/structure-of-a-wordprocessingml-document

Uses the Open XML SDK to initialize a document package and add a main document part containing a paragraph and text.

```C#
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;

static void CreateWordDoc(string filepath, string msg)
{
    using (WordprocessingDocument doc = WordprocessingDocument.Create(filepath, DocumentFormat.OpenXml.WordprocessingDocumentType.Document))
    {
        // Add a main document part. 
        MainDocumentPart mainPart = doc.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());

        // String msg contains the text from the msg parameter"
        run.AppendChild(new Text(msg));
    }
}
```

```VB
Imports DocumentFormat.OpenXml.Packaging
Imports DocumentFormat.OpenXml.Wordprocessing

Module MyModule

    Sub Main(args As String())
        CreateWordDoc(args(0), args(1))
    End Sub

    Sub CreateWordDoc(filepath As String, msg As String)
        Using doc As WordprocessingDocument = WordprocessingDocument.Create(filepath, DocumentFormat.OpenXml.WordprocessingDocumentType.Document)
            ' Add a main document part. 
            Dim mainPart As MainDocumentPart = doc.AddMainDocumentPart()

            ' Create the document structure and add some text.
            mainPart.Document = New Document()
            Dim body As Body = mainPart.Document.AppendChild(New Body())
            Dim para As Paragraph = body.AppendChild(New Paragraph())
            Dim run As Run = para.AppendChild(New Run())

            ' String msg contains the text from the msg parameter
            run.AppendChild(New Text(msg))
        End Using
    End Sub
End Module
```
Tokens:
Raw