Aspose.Words for .NET

https://reference.aspose.com/words/net/
Admin
Aspose.Words for .NET provides classes for generating, converting, modifying, rendering, and...
Tokens:4,014,291
Snippets:24,447
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Get phonetic guide properties example

Source: https://reference.aspose.com/words/net/aspose.words/phoneticguide/rubytext

Example that loads a document containing a phonetic guide and verifies the properties of the first run, including the RubyText property. It uses NUnit assertions to check that the run has a phonetic guide and that the base text and ruby text match expected values.

```csharp
Document doc = new Document(MyDir + "Phonetic guide.docx");

RunCollection runs = doc.FirstSection.Body.FirstParagraph.Runs;
// Use phonetic guide in the Asian text.
Assert.That(runs[0].IsPhoneticGuide, Is.EqualTo(true));
Assert.That(runs[0].PhoneticGuide.BaseText, Is.EqualTo("base"));
Assert.That(runs[0].PhoneticGuide.RubyText, Is.EqualTo("ruby"));
```

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

### Examples (AcceptEnd method)

Source: https://reference.aspose.com/words/net/aspose.words.notes/footnote/acceptend

Examples showing how to use the AcceptEnd method in conjunction with a DocumentVisitor to traverse footnote nodes.

```APIDOC
## Examples

### Description
Shows how to print the node structure of every footnote in a document.

### Example 1: Print the node structure of every footnote in a document

```csharp
Document doc = new Document(MyDir + "DocumentVisitor-compatible features.docx");
FootnoteStructurePrinter visitor = new FootnoteStructurePrinter();

// When we get a composite node to accept a document visitor, the visitor visits the accepting node,
// and then traverses all the node's children in a depth-first manner.
// The visitor can read and modify each visited node.
doc.Accept(visitor);

Console.WriteLine(visitor.GetText());
```

### Example 2: Print the node structure of every footnote in a document (FootnoteStructurePrinter)

```csharp
/// <summary>
/// Traverses a node's non-binary tree of child nodes.
/// Creates a map in the form of a string of all encountered Footnote nodes and their children.
/// </summary>
public class FootnoteStructurePrinter : DocumentVisitor
{
    public FootnoteStructurePrinter()
    {
        mBuilder = new StringBuilder();
        mVisitorIsInsideFootnote = false;
    }

    /// <summary>
    /// Gets the plain text of the document that was accumulated by the visitor.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Called when a Footnote node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFootnoteStart(Footnote footnote)
    {
        IndentAndAppendLine("[Footnote start] Type: " + footnote.FootnoteType);
        mDocTraversalDepth++;
        mVisitorIsInsideFootnote = true;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of a Footnote node have been visited.
    /// </summary>
    public override VisitorAction VisitFootnoteEnd(Footnote footnote)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Footnote end]");
        mVisitorIsInsideFootnote = false;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (mVisitorIsInsideFootnote) IndentAndAppendLine("[Run] \"" + run.GetText() + "\"");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Append a line to the StringBuilder and indent it depending on how deep the visitor is into the document tree.
    /// </summary>
    /// <param name="text"></param>
    private void IndentAndAppendLine(string text)
    {
        for (int i = 0; i < mDocTraversalDepth; i++) mBuilder.Append("|  ");

        mBuilder.AppendLine(text);
    }

    private bool mVisitorIsInsideFootnote;
    private int mDocTraversalDepth;
    private readonly StringBuilder mBuilder;
}
```

```

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

### BuildingBlock.AcceptStart(DocumentVisitor visitor)

Source: https://reference.aspose.com/words/net/aspose.words.buildingblocks/buildingblock/acceptstart

Accepts a visitor for visiting the start of the BuildingBlock. Returns the action to be taken by the visitor.

```APIDOC
## BuildingBlock.AcceptStart method

### Description
Accepts a visitor for visiting the start of the BuildingBlock.

### Method
`public override VisitorAction AcceptStart(DocumentVisitor visitor)`

### Parameters
- **visitor** (DocumentVisitor) - The document visitor.

### Return Value
The action to be taken by the visitor.
```

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

### Get match end node example

Source: https://reference.aspose.com/words/net/aspose.words.replacing/replacingargs/matchendnode

Shows how to get the match end node using the MatchEndNode property. The test creates a document with three lines, sets up a replacing callback, and replaces a regex pattern. The callback captures the text of the start and end nodes, and assertions verify the captured values.

```csharp
[Test]
public void MatchEndNode()
{
    Document doc = new Document();
    DocumentBuilder builder = new DocumentBuilder(doc);

    builder.Writeln("1");
    builder.Writeln("2");
    builder.Writeln("3");

    ReplacingCallback replacingCallback = new ReplacingCallback();
    FindReplaceOptions options = new FindReplaceOptions();
    options.ReplacingCallback = replacingCallback;

    doc.Range.Replace(new Regex("1[\\s\\S]*3"), "X", options);
    Assert.That(replacingCallback.StartNodeText, Is.EqualTo("1"));
    Assert.That(replacingCallback.EndNodeText, Is.EqualTo("3"));
}

/// <summary>
/// The replacing callback.
/// </summary>
private class ReplacingCallback : IReplacingCallback
{
    ReplaceAction IReplacingCallback.Replacing(ReplacingArgs e)
    {
        StartNodeText = e.MatchNode.GetText().Trim();
        EndNodeText = e.MatchEndNode.GetText().Trim();

        return ReplaceAction.Replace;
    }

    internal string StartNodeText { get; private set; }
    internal string EndNodeText { get; private set; }
}
```

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

### Construct an Aspose.Words document by hand

Source: https://reference.aspose.com/words/net/aspose.words/body/body

Shows how to create a document from scratch by removing default nodes, adding a section, body, paragraph, and run, then saving. Uses Assert to verify the text content.

```csharp
Document doc = new Document();

// A blank document contains one section, one body and one paragraph.
// Call the "RemoveAllChildren" method to remove all those nodes,
// and end up with a document node with no children.
doc.RemoveAllChildren();

// This document now has no composite child nodes that we can add content to.
// If we wish to edit it, we will need to repopulate its node collection.
// First, create a new section, and then append it as a child to the root document node.
Section section = new Section(doc);
doc.AppendChild(section);

// Set some page setup properties for the section.
section.PageSetup.SectionStart = SectionStart.NewPage;
section.PageSetup.PaperSize = PaperSize.Letter;

// A section needs a body, which will contain and display all its contents
// on the page between the section's header and footer.
Body body = new Body(doc);
section.AppendChild(body);

// Create a paragraph, set some formatting properties, and then append it as a child to the body.
Paragraph para = new Paragraph(doc);

para.ParagraphFormat.StyleName = "Heading 1";
para.ParagraphFormat.Alignment = ParagraphAlignment.Center;

body.AppendChild(para);

// Finally, add some content to do the document. Create a run,
// set its appearance and contents, and then append it as a child to the paragraph.
Run run = new Run(doc);
run.Text = "Hello World!";
run.Font.Color = Color.Red;
para.AppendChild(run);

Assert.That(doc.GetText().Trim(), Is.EqualTo("Hello World!"));

doc.Save(ArtifactsDir + "Section.CreateManually.docx");
```

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

### DocumentVisitor.VisitBodyStart method

Source: https://reference.aspose.com/words/net/aspose.words/documentvisitor/visitbodystart

Documentation for the DocumentVisitor.VisitBodyStart method, including its signature, parameters, return value, and usage examples.

```APIDOC
## DocumentVisitor.VisitBodyStart(Body body)

### Description
Called when enumeration of the main text story in a section has started.

### Method
VisitBodyStart

### Signature
public virtual VisitorAction VisitBodyStart(Body body)

### Parameters
- **body** (Body) - Required - The object that is being visited.

### Return Value
A `VisitorAction` value that specifies how to continue the enumeration.

### Examples
Shows how to use a document visitor to print a document's node structure.

```csharp
Document doc = new Document(MyDir + "DocumentVisitor-compatible features.docx");
DocStructurePrinter visitor = new DocStructurePrinter();

// When we get a composite node to accept a document visitor, the visitor visits the accepting node,
// and then traverses all the node's children in a depth-first manner.
// The visitor can read and modify each visited node.
doc.Accept(visitor);

Console.WriteLine(visitor.GetText());
```

Shows how to use a document visitor to print a document's node structure (DocStructurePrinter).

```csharp
/// <summary>
/// Traverses a node's tree of child nodes.
/// Creates a map of this tree in the form of a string.
/// </summary>
public class DocStructurePrinter : DocumentVisitor
{
    public DocStructurePrinter()
    {
        mAcceptingNodeChildTree = new StringBuilder();
    }

    public string GetText()
    {
        return mAcceptingNodeChildTree.ToString();
    }

    /// <summary>
    /// Called when a Document node is encountered.
    /// </summary>
    public override VisitorAction VisitDocumentStart(Document doc)
    {
        int childNodeCount = doc.GetChildNodes(NodeType.Any, true).Count;

        IndentAndAppendLine("[Document start] Child nodes: " + childNodeCount);
        mDocTraversalDepth++;

        // Allow the visitor to continue visiting other nodes.
        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of a Document node have been visited.
    /// </summary>
    public override VisitorAction VisitDocumentEnd(Document doc)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Document end]");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Section node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitSectionStart(Section section)
    {
        // Get the index of our section within the document.
        NodeCollection docSections = section.Document.GetChildNodes(NodeType.Section, false);
        int sectionIndex = docSections.IndexOf(section);

        IndentAndAppendLine("[Section start] Section index: " + sectionIndex);
        mDocTraversalDepth++;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of a Section node have been visited.
    /// </summary>
    public override VisitorAction VisitSectionEnd(Section section)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Section end]");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Body node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitBodyStart(Body body)
    {
        int paragraphCount = body.Paragraphs.Count;
        IndentAndAppendLine("[Body start] Paragraphs: " + paragraphCount);
        mDocTraversalDepth++;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of a Body node have been visited.
    /// </summary>
    public override VisitorAction VisitBodyEnd(Body body)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Body end]");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Paragraph node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitParagraphStart(Paragraph paragraph)
    {
        IndentAndAppendLine("[Paragraph start]");
        mDocTraversalDepth++;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of a Paragraph node have been visited.
    /// </summary>
    public override VisitorAction VisitParagraphEnd(Paragraph paragraph)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Paragraph end]");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        IndentAndAppendLine("[Run] \"" + run.GetText() + "\"");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a SubDocument node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitSubDocument(SubDocument subDocument)
    {
        IndentAndAppendLine("[SubDocument]");

        return VisitorAction.Continue;
    }
}
```
```

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

### MustacheTag.ReferenceOffset property

Source: https://reference.aspose.com/words/net/aspose.words.mailmerging/mustachetag/referenceoffset

Gets the zero-based starting position of the tag from the start of the ReferenceRun.

```csharp
public int ReferenceOffset { get; }
```

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

### Convert documents with Converter.Convert examples

Source: https://reference.aspose.com/words/net/aspose.words.lowcode/converter/convert

Shows how to convert documents with a single line of code using the Converter class. Demonstrates basic conversion, specifying a save format, and using load and save options. The example uses MyDir and ArtifactsDir placeholders for input and output directories.

```csharp
string doc = MyDir + "Document.docx";

Converter.Convert(doc, ArtifactsDir + "LowCode.Convert.pdf");

Converter.Convert(doc, ArtifactsDir + "LowCode.Convert.SaveFormat.rtf", SaveFormat.Rtf);

OoxmlSaveOptions saveOptions = new OoxmlSaveOptions { Password = "Aspose.Words" };
LoadOptions loadOptions = new LoadOptions() { IgnoreOleData = true };
Converter.Convert(doc, loadOptions, ArtifactsDir + "LowCode.Convert.LoadOptions.docx", saveOptions);

Converter.Convert(doc, ArtifactsDir + "LowCode.Convert.SaveOptions.docx", saveOptions);
```

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

### Range Usage Example

Source: https://reference.aspose.com/words/net/aspose.words/range

Example showing how to get the text contents of all the nodes that a range covers.

```APIDOC
## Example: Getting Range Text

### Description
Shows how to get the text contents of all the nodes that a range covers.

### Code
```csharp
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.Write("Hello world!");

Assert.That(doc.Range.Text.Trim(), Is.EqualTo("Hello world!"));
```
```

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

### ReplacingArgs.MatchOffset property

Source: https://reference.aspose.com/words/net/aspose.words.replacing/replacingargs/matchoffset

Gets the zero-based starting position of the match from the start of the node that contains the beginning of the match.

```csharp
public int MatchOffset { get; }
```

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

### Example: Convert IANA media types to load/save formats

Source: https://reference.aspose.com/words/net/aspose.words/fileformatutil/contenttypetosaveformat

Example shows how to find the corresponding Aspose load/save format from each media type string. It demonstrates that only official IANA media type names are accepted, and that invalid or unsupported types throw ArgumentException.

```csharp
// The ContentTypeToSaveFormat/ContentTypeToLoadFormat methods only accept official IANA media type names, also known as MIME types. 
// All valid media types are listed here: https://www.iana.org/assignments/media-types/media-types.xhtml.

// Trying to associate a SaveFormat with a partial media type string will not work.
Assert.Throws<ArgumentException>(() => FileFormatUtil.ContentTypeToSaveFormat("jpeg"));

// If Aspose.Words does not have a corresponding save/load format for a content type, an exception will also be thrown.
Assert.Throws<ArgumentException>(() => FileFormatUtil.ContentTypeToSaveFormat("application/zip"));

// Files of the types listed below can be saved, but not loaded using Aspose.Words.
Assert.Throws<ArgumentException>(() => FileFormatUtil.ContentTypeToLoadFormat("image/jpeg"));

Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/jpeg"), Is.EqualTo(SaveFormat.Jpeg));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/png"), Is.EqualTo(SaveFormat.Png));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/tiff"), Is.EqualTo(SaveFormat.Tiff));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/gif"), Is.EqualTo(SaveFormat.Gif));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/x-emf"), Is.EqualTo(SaveFormat.Emf));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("application/vnd.ms-xpsdocument"), Is.EqualTo(SaveFormat.Xps));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("application/pdf"), Is.EqualTo(SaveFormat.Pdf));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("image/svg+xml"), Is.EqualTo(SaveFormat.Svg));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("application/epub+zip"), Is.EqualTo(SaveFormat.Epub));

// For file types that can be saved and loaded, we can match a media type to both a load format and a save format.
Assert.That(FileFormatUtil.ContentTypeToLoadFormat("application/msword"), Is.EqualTo(LoadFormat.Doc));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("application/msword"), Is.EqualTo(SaveFormat.Doc));

Assert.That(FileFormatUtil.ContentTypeToLoadFormat(
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"), Is.EqualTo(LoadFormat.Docx));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat(
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"), Is.EqualTo(SaveFormat.Docx));

Assert.That(FileFormatUtil.ContentTypeToLoadFormat("text/plain"), Is.EqualTo(LoadFormat.Text));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("text/plain"), Is.EqualTo(SaveFormat.Text));

Assert.That(FileFormatUtil.ContentTypeToLoadFormat("application/rtf"), Is.EqualTo(LoadFormat.Rtf));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("application/rtf"), Is.EqualTo(SaveFormat.Rtf));

Assert.That(FileFormatUtil.ContentTypeToLoadFormat("text/html"), Is.EqualTo(LoadFormat.Html));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("text/html"), Is.EqualTo(SaveFormat.Html));

Assert.That(FileFormatUtil.ContentTypeToLoadFormat("multipart/related"), Is.EqualTo(LoadFormat.Mhtml));
Assert.That(FileFormatUtil.ContentTypeToSaveFormat("multipart/related"), Is.EqualTo(SaveFormat.Mhtml));
```

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

### DocumentVisitor.VisitFieldStart method

Source: https://reference.aspose.com/words/net/aspose.words/documentvisitor/visitfieldstart

Documentation for the DocumentVisitor.VisitFieldStart method, including its signature, parameters, return value, remarks, and examples.

```APIDOC
## DocumentVisitor.VisitFieldStart method

### Description
Called when a field starts in the document. A field in a Word document consists of a field code and field value. The field separator separates field code from field value in the document. Fields can be nested.

### Method
VisitFieldStart

### Signature
public virtual VisitorAction VisitFieldStart(FieldStart fieldStart)

### Parameters
- **fieldStart** (FieldStart) - Required - The object that is being visited.

### Return Value
A `VisitorAction` value that specifies how to continue the enumeration.

### Remarks
A field in a Word document consists of a field code and field value. For example, a field that displays a page number can be represented as follows: [FieldStart]PAGE[FieldSeparator]98[FieldEnd]. The field separator separates field code from field value in the document. Note that some fields have only field code and do not have field separator and field value. Fields can be nested.

### Examples
Shows how to print the node structure of every field in a document.
```csharp
Document doc = new Document(MyDir + "DocumentVisitor-compatible features.docx");
FieldStructurePrinter visitor = new FieldStructurePrinter();

// When we get a composite node to accept a document visitor, the visitor visits the accepting node,
// and then traverses all the node's children in a depth-first manner.
// The visitor can read and modify each visited node.
doc.Accept(visitor);

Console.WriteLine(visitor.GetText());
```

Shows how to print the node structure of every field in a document (FieldStructurePrinter).
```csharp
/// <summary>
/// Traverses a node's non-binary tree of child nodes.
/// Creates a map in the form of a string of all encountered Field nodes and their children.
/// </summary>
public class FieldStructurePrinter : DocumentVisitor
{
    public FieldStructurePrinter()
    {
        mBuilder = new StringBuilder();
        mVisitorIsInsideField = false;
    }

    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (mVisitorIsInsideField) IndentAndAppendLine("[Run] \"" + run.GetText() + "\"");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldStart node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldStart(FieldStart fieldStart)
    {
        IndentAndAppendLine("[Field start] FieldType: " + fieldStart.FieldType);
        mDocTraversalDepth++;
        mVisitorIsInsideField = true;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldEnd node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[Field end]");
        mVisitorIsInsideField = false;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldSeparator node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        IndentAndAppendLine("[FieldSeparator]");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Append a line to the StringBuilder, and indent it depending on how deep the visitor is
    /// into the field's tree of child nodes.
    /// </summary>
    /// <param name="text"></param>
    private void IndentAndAppendLine(string text)
    {
        for (int i = 0; i < mDocTraversalDepth; i++)
        {
            mBuilder.Append("|  ");
        }

        mBuilder.AppendLine(text);
    }

    private bool mVisitorIsInsideField;
    private int mDocTraversalDepth;
    private readonly StringBuilder mBuilder;
}
```

### See Also
- enum VisitorAction
- class FieldStart
- class DocumentVisitor
- namespace Aspose.Words
- assembly Aspose.Words
```

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

### FieldListNum.StartingNumber property

Source: https://reference.aspose.com/words/net/aspose.words.fields/fieldlistnum/startingnumber

Gets or sets the starting value for a LISTNUM field. The property is a string that represents the starting number.

```APIDOC
## FieldListNum.StartingNumber property

### Description
Gets or sets the starting value for this field.

### Property Signature
```csharp
public string StartingNumber { get; set; }
```

### Property Value
- **Type**: string
- **Access**: Read/Write

### Remarks
This property allows you to set the starting number for the LISTNUM field. By default, lists start counting at 1, but you can set this to a different value, such as 0.

### Examples
Shows how to number paragraphs with LISTNUM fields.

```csharp
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// LISTNUM fields display a number that increments at each LISTNUM field.
// These fields also have a variety of options that allow us to use them to emulate numbered lists.
FieldListNum field = (FieldListNum)builder.InsertField(FieldType.FieldListNum, true);

// Lists start counting at 1 by default, but we can set this number to a different value, such as 0.
// This field will display "0)".
field.StartingNumber = "0";
builder.Writeln("Paragraph 1");

Assert.That(field.GetFieldCode(), Is.EqualTo(" LISTNUM  \\s 0"));

// LISTNUM fields maintain separate counts for each list level. 
// Inserting a LISTNUM field in the same paragraph as another LISTNUM field
// increases the list level instead of the count.
// The next field will continue the count we started above and display a value of "1" at list level 1.
builder.InsertField(FieldType.FieldListNum, true);

// This field will start a count at list level 2. It will display a value of "1".
builder.InsertField(FieldType.FieldListNum, true);

// This field will start a count at list level 3. It will display a value of "1".
// Different list levels have different formatting,
// so these fields combined will display a value of "1)a)i)".
builder.InsertField(FieldType.FieldListNum, true);
builder.Writeln("Paragraph 2");

// The next LISTNUM field that we insert will continue the count at the list level
// that the previous LISTNUM field was on.
// We can use the "ListLevel" property to jump to a different list level.
// If this LISTNUM field stayed on list level 3, it would display "ii)",
// but, since we have moved it to list level 2, it carries on the count at that level and displays "b)".
field = (FieldListNum)builder.InsertField(FieldType.FieldListNum, true);
field.ListLevel = "2";
builder.Writeln("Paragraph 3");

Assert.That(field.GetFieldCode(), Is.EqualTo(" LISTNUM  \\l 2"));

// We can set the ListName property to get the field to emulate a different AUTONUM field type.
// "NumberDefault" emulates AUTONUM, "OutlineDefault" emulates AUTONUMOUT,
// and "LegalDefault" emulates AUTONUMLGL fields.
// The "OutlineDefault" list name with 1 as the starting number will result in displaying "I.".
field = (FieldListNum)builder.InsertField(FieldType.FieldListNum, true);
field.StartingNumber = "1";
field.ListName = "OutlineDefault";
builder.Writeln("Paragraph 4");

Assert.That(field.HasListName, Is.True);
Assert.That(field.GetFieldCode(), Is.EqualTo(" LISTNUM  OutlineDefault \\s 1"));

// The ListName does not carry over from the previous field, so we will need to set it for each new field.
// This field continues the count with the different list name and displays "II.".
field = (FieldListNum)builder.InsertField(FieldType.FieldListNum, true);
field.ListName = "OutlineDefault";
builder.Writeln("Paragraph 5");

doc.UpdateFields();
doc.Save(ArtifactsDir + "Field.LISTNUM.docx");
```

### See Also
- class FieldListNum
- namespace Aspose.Words.Fields
- assembly Aspose.Words
```

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

### Get StartMustacheTag property

Source: https://reference.aspose.com/words/net/aspose.words.mailmerging/mailmergeregioninfo/startmustachetag

Gets the start mustache tag for the region. The property is read-only and returns a MustacheTag object.

```csharp
public MustacheTag StartMustacheTag { get; }
```

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

### OfficeMath.AcceptStart(DocumentVisitor)

Source: https://reference.aspose.com/words/net/aspose.words.math/officemath/acceptstart

Accepts a visitor for visiting the start of the office math. The visitor can read and modify the visited node.

```APIDOC
## OfficeMath.AcceptStart(DocumentVisitor)

### Description
Accepts a visitor for visiting the start of the office math. The visitor can read and modify the visited node.

### Method
AcceptStart

### Signature
public override VisitorAction AcceptStart(DocumentVisitor visitor)

### Parameters
- **visitor** (DocumentVisitor) - Required - The document visitor.

### Return Value
VisitorAction - The action to be taken by the visitor.

### Examples
Shows how to print the node structure of every office math node in a document.

```csharp
Document doc = new Document(MyDir + "DocumentVisitor-compatible features.docx");
OfficeMathStructurePrinter visitor = new OfficeMathStructurePrinter();

// When we get a composite node to accept a document visitor, the visitor visits the accepting node,
// and then traverses all the node's children in a depth-first manner.
// The visitor can read and modify each visited node.
doc.Accept(visitor);

Console.WriteLine(visitor.GetText());
```

Shows how to print the node structure of every office math node in a document (OfficeMathStructurePrinter).

```csharp
/// <summary>
/// Traverses a node's non-binary tree of child nodes.
/// Creates a map in the form of a string of all encountered OfficeMath nodes and their children.
/// </summary>
public class OfficeMathStructurePrinter : DocumentVisitor
{
    public OfficeMathStructurePrinter()
    {
        mBuilder = new StringBuilder();
        mVisitorIsInsideOfficeMath = false;
    }

    /// <summary>
    /// Gets the plain text of the document that was accumulated by the visitor.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (mVisitorIsInsideOfficeMath) IndentAndAppendLine("[Run] \"" + run.GetText() + "\"");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when an OfficeMath node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitOfficeMathStart(OfficeMath officeMath)
    {
        IndentAndAppendLine("[OfficeMath start] Math object type: " + officeMath.MathObjectType);
        mDocTraversalDepth++;
        mVisitorIsInsideOfficeMath = true;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of an OfficeMath node have been visited.
    /// </summary>
    public override VisitorAction VisitOfficeMathEnd(OfficeMath officeMath)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[OfficeMath end]");
        mVisitorIsInsideOfficeMath = false;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Append a line to the StringBuilder and indent it depending on how deep the visitor is into the document tree.
    /// </summary>
    /// <param name="text"></param>
    private void IndentAndAppendLine(string text)
    {
        for (int i = 0; i < mDocTraversalDepth; i++) mBuilder.Append("|  ");

        mBuilder.AppendLine(text);
    }

    private bool mVisitorIsInsideOfficeMath;
    private int mDocTraversalDepth;
    private readonly StringBuilder mBuilder;
}
```

### See Also
- enum VisitorAction
- class DocumentVisitor
- class OfficeMath
- namespace Aspose.Words.Math
- assembly Aspose.Words
```

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

### Source.Guid property declaration

Source: https://reference.aspose.com/words/net/aspose.words.bibliography/source/guid

Property declaration for the Guid property of the Source class. Gets or sets the guid of a source.

```csharp
public string Guid { get; set; }
```

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

### Paragraph.AcceptStart(DocumentVisitor visitor)

Source: https://reference.aspose.com/words/net/aspose.words/paragraph/acceptstart

Documentation for the Paragraph.AcceptStart method, including its signature, parameters, return value, and a usage example.

```APIDOC
## Paragraph.AcceptStart(DocumentVisitor visitor)

### Description
Accepts a visitor for visiting the start of the document's paragraph.

### Method
AcceptStart

### Signature
public override VisitorAction AcceptStart(DocumentVisitor visitor)

### Parameters
- **visitor** (DocumentVisitor) - Required - The document visitor.

### Return Value
VisitorAction - The action to be taken by the visitor.

### Example
Shows how to use a DocumentVisitor implementation to remove all hidden content from a document.

```csharp
public void RemoveHiddenContentFromDocument()
{
    Document doc = new Document(MyDir + "Hidden content.docx");
    RemoveHiddenContentVisitor hiddenContentRemover = new RemoveHiddenContentVisitor();

    // Below are three types of fields which can accept a document visitor,
    // which will allow it to visit the accepting node, and then traverse its child nodes in a depth-first manner.
    // 1 -  Paragraph node:
    Paragraph para = (Paragraph)doc.GetChild(NodeType.Paragraph, 4, true);
    para.Accept(hiddenContentRemover);

    // 2 -  Table node:
    Table table = doc.FirstSection.Body.Tables[0];
    table.Accept(hiddenContentRemover);

    // 3 -  Document node:
    doc.Accept(hiddenContentRemover);

    doc.Save(ArtifactsDir + "Font.RemoveHiddenContentFromDocument.docx");
}

/// <summary>
/// Removes all visited nodes marked as "hidden content".
/// </summary>
public class RemoveHiddenContentVisitor : DocumentVisitor
{
    /// <summary>
    /// Called when a FieldStart node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldStart(FieldStart fieldStart)
    {
        if (fieldStart.Font.Hidden)
            fieldStart.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldEnd node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        if (fieldEnd.Font.Hidden)
            fieldEnd.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldSeparator node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        if (fieldSeparator.Font.Hidden)
            fieldSeparator.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (run.Font.Hidden)
            run.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Paragraph node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitParagraphStart(Paragraph paragraph)
    {
        if (paragraph.ParagraphBreakFont.Hidden)
            paragraph.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FormField is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFormField(FormField formField)
    {
        if (formField.Font.Hidden)
            formField.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a GroupShape is encountered in the document.
    /// </summary>
    public override VisitorAction VisitGroupShapeStart(GroupShape groupShape)
    {
        if (groupShape.Font.Hidden)
            groupShape.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Shape is encountered in the document.
    /// </summary>
    public override VisitorAction VisitShapeStart(Shape shape)
    {
        if (shape.Font.Hidden)
            shape.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Comment is encountered in the document.
    /// </summary>
    public override VisitorAction VisitCommentStart(Comment comment)
    {
        if (comment.Font.Hidden)
            comment.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a Footnote is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFootnoteStart(Footnote footnote)
    {
        if (footnote.Font.Hidden)
            footnote.Remove();

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a SpecialCharacter is encountered in the document.
    /// </summary>
    public override VisitorAction VisitSpecialChar(SpecialChar specialChar)
    {
        Console.WriteLine(specialChar.GetText());

        if (specialChar.Font.Hidden)
            specialChar.Remove();

        return VisitorAction.Continue;
    }
}
```
```

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

### DocumentVisitor.VisitOfficeMathStart

Source: https://reference.aspose.com/words/net/aspose.words/documentvisitor/visitofficemathstart

Documentation for the DocumentVisitor.VisitOfficeMathStart method, including its signature, parameters, return value, and usage examples.

```APIDOC
## VisitOfficeMathStart

### Description
Called when enumeration of a Office Math object has started.

### Method
VisitOfficeMathStart

### Signature
public virtual VisitorAction VisitOfficeMathStart(OfficeMath officeMath)

### Parameters
- **officeMath** (OfficeMath) - The object that is being visited.

### Return Value
A `VisitorAction` value that specifies how to continue the enumeration.

### Examples
Shows how to print the node structure of every office math node in a document.

```csharp
Document doc = new Document(MyDir + "DocumentVisitor-compatible features.docx");
OfficeMathStructurePrinter visitor = new OfficeMathStructurePrinter();

// When we get a composite node to accept a document visitor, the visitor visits the accepting node,
// and then traverses all the node's children in a depth-first manner.
// The visitor can read and modify each visited node.
doc.Accept(visitor);

Console.WriteLine(visitor.GetText());
```

Shows how to print the node structure of every office math node in a document (OfficeMathStructurePrinter).

```csharp
/// <summary>
/// Traverses a node's non-binary tree of child nodes.
/// Creates a map in the form of a string of all encountered OfficeMath nodes and their children.
/// </summary>
public class OfficeMathStructurePrinter : DocumentVisitor
{
    public OfficeMathStructurePrinter()
    {
        mBuilder = new StringBuilder();
        mVisitorIsInsideOfficeMath = false;
    }

    /// <summary>
    /// Gets the plain text of the document that was accumulated by the visitor.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (mVisitorIsInsideOfficeMath) IndentAndAppendLine("[Run] \"" + run.GetText() + "\"");

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when an OfficeMath node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitOfficeMathStart(OfficeMath officeMath)
    {
        IndentAndAppendLine("[OfficeMath start] Math object type: " + officeMath.MathObjectType);
        mDocTraversalDepth++;
        mVisitorIsInsideOfficeMath = true;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called after all the child nodes of an OfficeMath node have been visited.
    /// </summary>
    public override VisitorAction VisitOfficeMathEnd(OfficeMath officeMath)
    {
        mDocTraversalDepth--;
        IndentAndAppendLine("[OfficeMath end]");
        mVisitorIsInsideOfficeMath = false;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Append a line to the StringBuilder and indent it depending on how deep the visitor is into the document tree.
    /// </summary>
    /// <param name="text"></param>
    private void IndentAndAppendLine(string text)
    {
        for (int i = 0; i < mDocTraversalDepth; i++) mBuilder.Append("|  ");

        mBuilder.AppendLine(text);
    }

    private bool mVisitorIsInsideOfficeMath;
    private int mDocTraversalDepth;
    private readonly StringBuilder mBuilder;
}
```

### See Also
- enum VisitorAction
- class OfficeMath
- class DocumentVisitor
- namespace Aspose.Words
- assembly Aspose.Words
```

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

### PhoneticGuide Class

Source: https://reference.aspose.com/words/net/aspose.words/phoneticguide

Represents a phonetic guide. Provides properties to get the base text and ruby text of the guide.

```APIDOC
## PhoneticGuide Class

### Description
Represents Phonetic Guide.

### Class Declaration
```csharp
public class PhoneticGuide
```

### Properties

#### BaseText
- **Type:** string (get)
- **Description:** Gets base text of the phonetic guide.

#### RubyText
- **Type:** string (get)
- **Description:** Gets ruby text of the phonetic guide.

### See Also
- Namespace: Aspose.Words
- Assembly: Aspose.Words
```

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

### GlossaryDocument.AcceptStart(DocumentVisitor visitor)

Source: https://reference.aspose.com/words/net/aspose.words.buildingblocks/glossarydocument/acceptstart

Accepts a visitor for visiting the start of the Glossary document. The visitor parameter is the document visitor, and the method returns the action to be taken by the visitor.

```APIDOC
## GlossaryDocument.AcceptStart(DocumentVisitor visitor)

### Description
Accepts a visitor for visiting the start of the Glossary document.

### Method
AcceptStart

### Signature
public override VisitorAction AcceptStart(DocumentVisitor visitor)

### Parameters
- **visitor** (DocumentVisitor) - Required - The document visitor.

### Return Value
VisitorAction - The action to be taken by the visitor.
```

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

### Field.Start property

Source: https://reference.aspose.com/words/net/aspose.words.fields/field/start

Gets the node that represents the start of the field.

```APIDOC
## Field.Start property

### Description
Gets the node that represents the start of the field.

### Property Signature
```
public FieldStart Start { get; }
```

### Property Value
- **Type**: FieldStart
- **Description**: The node that represents the start of the field.

### Examples

#### Example 1: Working with a collection of fields
```
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.InsertField(" DATE \\@ \"dddd, d MMMM yyyy\" ");
builder.InsertField(" TIME ");
builder.InsertField(" REVNUM ");
builder.InsertField(" AUTHOR  \"John Doe\" ");
builder.InsertField(" SUBJECT \"My Subject\" ");
builder.InsertField(" QUOTE \"Hello world!\" ");
doc.UpdateFields();

FieldCollection fields = doc.Range.Fields;

Assert.That(fields.Count, Is.EqualTo(6));

// Iterate over the field collection, and print contents and type
// of every field using a custom visitor implementation.
FieldVisitor fieldVisitor = new FieldVisitor();

using (IEnumerator<Field> fieldEnumerator = fields.GetEnumerator())
{
    while (fieldEnumerator.MoveNext())
    {
        if (fieldEnumerator.Current != null)
        {
            fieldEnumerator.Current.Start.Accept(fieldVisitor);
            fieldEnumerator.Current.Separator?.Accept(fieldVisitor);
            fieldEnumerator.Current.End.Accept(fieldVisitor);
        }
        else
        {
            Console.WriteLine("There are no fields in the document.");
        }
    }
}

Console.WriteLine(fieldVisitor.GetText());
```

#### Example 2: FieldVisitor implementation
```
/// <summary>
/// Document visitor implementation that prints field info.
/// </summary>
public class FieldVisitor : DocumentVisitor
{
    public FieldVisitor()
    {
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Gets the plain text of the document that was accumulated by the visitor.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Called when a FieldStart node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldStart(FieldStart fieldStart)
    {
        mBuilder.AppendLine("Found field: " + fieldStart.FieldType);
        mBuilder.AppendLine("\tField code: " + fieldStart.GetField().GetFieldCode());
        mBuilder.AppendLine("\tDisplayed as: " + fieldStart.GetField().Result);

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldSeparator node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        mBuilder.AppendLine("\tFound separator: " + fieldSeparator.GetText());

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Called when a FieldEnd node is encountered in the document.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mBuilder.AppendLine("End of field: " + fieldEnd.FieldType);

        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
}
```

### See Also
- class FieldStart
- class Field
- namespace Aspose.Words.Fields
- assembly Aspose.Words
```

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

### Field.Start property

Source: https://reference.aspose.com/words/net/aspose.words.fields/field/start

Gets the node that represents the start of the field.

```csharp
public FieldStart Start { get; }
```

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

### Example: Constructing a Document by Hand

Source: https://reference.aspose.com/words/net/aspose.words/paragraphformat

Shows how to construct an Aspose.Words document by hand, including setting paragraph formatting properties.

```APIDOC
## Example: Constructing a Document by Hand

### Description
Demonstrates how to create a document manually, including setting paragraph formatting properties such as style name and alignment.

### Code
```csharp
Document doc = new Document();

// A blank document contains one section, one body and one paragraph.
// Call the "RemoveAllChildren" method to remove all those nodes,
// and end up with a document node with no children.
doc.RemoveAllChildren();

// This document now has no composite child nodes that we can add content to.
// If we wish to edit it, we will need to repopulate its node collection.
// First, create a new section, and then append it as a child to the root document node.
Section section = new Section(doc);
doc.AppendChild(section);

// Set some page setup properties for the section.
section.PageSetup.SectionStart = SectionStart.NewPage;
section.PageSetup.PaperSize = PaperSize.Letter;

// A section needs a body, which will contain and display all its contents
// on the page between the section's header and footer.
Body body = new Body(doc);
section.AppendChild(body);

// Create a paragraph, set some formatting properties, and then append it as a child to the body.
Paragraph para = new Paragraph(doc);

para.ParagraphFormat.StyleName = "Heading 1";
para.ParagraphFormat.Alignment = ParagraphAlignment.Center;

body.AppendChild(para);

// Finally, add some content to do the document. Create a run,
// set its appearance and contents, and then append it as a child to the paragraph.
Run run = new Run(doc);
run.Text = "Hello World!";
run.Font.Color = Color.Red;
para.AppendChild(run);

Assert.That(doc.GetText().Trim(), Is.EqualTo("Hello World!"));

doc.Save(ArtifactsDir + "Section.CreateManually.docx");
```
```

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

### Get a revision group by index

Source: https://reference.aspose.com/words/net/aspose.words/revisiongroupcollection/item

Example showing how to get a revision group from a document's revision groups collection using the indexer.

```csharp
Document doc = new Document(MyDir + "Revisions.docx");

RevisionGroup revisionGroup = doc.Revisions.Groups[0];
```
Tokens:
Raw