Aspose.Words Document Object Model (DOM)

De Aspose.Words Document Object Model (DOM) is een herinneringsrepresentatie van een Word-document. De Aspose.Words DOM Hiermee kunt u programmatisch de inhoud en opmaak van een Word-document lezen, manipuleren en wijzigen.

Dit deel beschrijft de belangrijkste klassen van de Aspose.Words DOM en hun relaties. Door het gebruik van de Aspose.Words DOM klassen, kunt u programmatische toegang tot document elementen en opmaak verkrijgen.

Aanmaken Document Objectboom

Wanneer een document wordt gelezen in de Aspose.Words DOM dan wordt er een objectboom gebouwd en hebben verschillende soorten elementen van het brondocument hun eigen DOM boomobjecten met verschillende eigenschappen.

Documentnodesboom bouwen

Wanneer Aspose.Words leest een Word-document in het geheugen, het creëert objecten van verschillende soorten die verschillende documentelementen vertegenwoordigen. Elke run van een tekst, paragraaf, tabel, of een sectie is een knooppunt, en zelfs het document zelf is een knooppunt. Aspose.Words definieert een klasse voor elk documentnodetype.

De documentboom in Aspose.Words volgt het samengestelde ontwerppatroon:

  • Alle knooppuntklassen komen uiteindelijk voort uit de Node klasse, dat is de basisklasse in de Aspose.Words Document Object Model.
  • Knooppunten die andere knooppunten kunnen bevatten, bijvoorbeeld, Section of Paragraph, de CompositeNode klasse, die op zijn beurt voortvloeit uit de Node Klasse.

Het onderstaande diagram toont de erfenis tussen de knooppuntklassen van de Aspose.Words Document Object Model (DOM). De namen van abstracte klassen zijn in cursief.

aspose-words-dom

Laten we naar een voorbeeld kijken. De volgende afbeelding toont een Microsoft Word document met verschillende soorten inhoud.

document-example-aspose-words

Bij het lezen van het bovenstaande document in de Aspose.Words DOM, de boom van objecten is gemaakt, zoals getoond in het schema hieronder.

dom-aspose-words

Document, Section, Paragraph, Table, Shape, Run, en alle andere ellipsen op het diagram zijn Aspose.Words objecten die elementen van het Word-document weergeven.

Haal een Node Type

Hoewel de Node klasse is voldoende om verschillende knooppunten van elkaar te onderscheiden; Aspose.Words levert de NodeType Lijst ter vereenvoudiging van sommige API taken, zoals het selecteren van knooppunten van een specifiek type.

Het type van elke knoop kan worden verkregen met behulp van de NodeType eigendom. Deze eigenschap geeft een NodeType Waarde van de opsomming. Een paragraaf die bijvoorbeeld door de Paragraph klasse geeft terug NodeType.Paragraph, en een tabel knooppunt vertegenwoordigd door de Table klasse geeft terug NodeType.Table.

Het volgende voorbeeld laat zien hoe je een knooppunt type met behulp van de NodeType Lijst:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
// Returns NodeType.Document
NodeType type = doc.NodeType;

Documentboomnavigatie

Aspose.Words vertegenwoordigt een document als een knooppunt boom, waarmee u kunt navigeren tussen knooppunten. Deze sectie beschrijft hoe u de documentboom kunt verkennen en navigeren in Aspose.Words.

Wanneer u het voorbeelddocument opent, dat eerder in de Document Explorer wordt getoond, verschijnt de knooppuntboom precies zoals deze is weergegeven in Aspose.Words.

document-in-document-explorer

Relaties tussen documentknooppunten

De knooppunten in de boom hebben relaties tussen hen:

  • Een knooppunt met een ander knooppunt is een parent.
  • Het knooppunt in het ouderknooppunt is een child. Kindknooppunten van dezelfde ouder zijn sibling knooppunten.
  • De root knooppunt is altijd de Document Node.

De knooppunten die andere knooppunten kunnen bevatten zijn afkomstig van de CompositeNode klasse, en alle knooppunten uiteindelijk afkomstig zijn van de Node Klasse. Deze twee basisklassen bieden gemeenschappelijke methoden en eigenschappen voor de navigatie en modificatie van de boomstructuur.

Het volgende UML object diagram toont verschillende knooppunten van het monster document en hun relaties met elkaar via de ouder, kind en broer eigenschappen:

document-nodes-relationships-aspose-words

Document is Node-eigenaar

Een knooppunt behoort altijd tot een bepaald document, zelfs als het net is gemaakt of verwijderd uit de boom, omdat vitale document-brede structuren zoals stijlen en lijsten worden opgeslagen in de Document Node. Het is bijvoorbeeld niet mogelijk om een Paragraph zonder een Document omdat elke alinea een toegewezen stijl heeft die wereldwijd voor het document wordt gedefinieerd. Deze regel wordt gebruikt bij het aanmaken van nieuwe nodes. Een nieuw toevoegen Paragraph rechtstreeks naar de DOM vereist een document object doorgegeven aan de constructeur.

Bij het aanmaken van een nieuwe paragraaf DocumentBuilder, de bouwer heeft altijd een Document klasse verbonden aan het via de DocumentBuilder.Document eigendom.

Het volgende voorbeeld toont aan dat bij het aanmaken van een node, een document dat eigenaar van de node is altijd wordt gedefinieerd:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Open a file from disk.
Document doc = new Document();
// Creating a new node of any type requires a document passed into the constructor.
Paragraph para = new Paragraph(doc);
// The new paragraph node does not yet have a parent.
Console.WriteLine("Paragraph has no parent node: " + (para.ParentNode == null));
// But the paragraph node knows its document.
Console.WriteLine("Both nodes' documents are the same: " + (para.Document == doc));
// The fact that a node always belongs to a document allows us to access and modify
// Properties that reference the document-wide data such as styles or lists.
para.ParagraphFormat.StyleName = "Heading 1";
// Now add the paragraph to the main text of the first section.
doc.FirstSection.Body.AppendChild(para);
// The paragraph node is now a child of the Body node.
Console.WriteLine("Paragraph has a parent node: " + (para.ParentNode != null));

Ouderknooppunt

Elke knooppunt heeft een ouder gespecificeerd door de ParentNode eigendom. Een knooppunt heeft geen oudernode, dat wil zeggen, ParentNode nul is, in de volgende gevallen:

  • Het knooppunt is zojuist aangemaakt en is nog niet aan de boom toegevoegd.
  • Het knooppunt is uit de boom verwijderd.
  • Dit is de root Document knooppunt dat altijd een nul ouder knooppunt heeft.

U kunt een knooppunt verwijderen van de ouder door de Remove methode. Het volgende voorbeeld van code laat zien hoe toegang te krijgen tot het ouderknooppunt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Create a new empty document. It has one section.
Document doc = new Document();
// The section is the first child node of the document.
Node section = doc.FirstChild;
// The section's parent node is the document.
Console.WriteLine("Section parent is the document: " + (doc == section.ParentNode));

Kindknooppunten

De meest efficiënte manier om toegang te krijgen tot kinderknooppunten van een CompositeNode via de FirstChild en LastChild eigenschappen die respectievelijk de eerste en laatste kindknooppunten teruggeven. Als er geen kindknopen zijn, keren deze eigenschappen terug null.

CompositeNode de GetChildNodes methode die geïndexeerde of gespecificeerde toegang tot de kindknooppunten mogelijk maakt. De ChildNodes eigenschap is een levende verzameling van knooppunten, wat betekent dat wanneer het document wordt gewijzigd, zoals wanneer knooppunten worden verwijderd of toegevoegd, de ChildNodes collectie wordt automatisch bijgewerkt.

Als een knooppunt geen kind heeft, dan de ChildNodes object geeft een lege verzameling terug. U kunt controleren of de CompositeNode bevat alle kindknooppunten met behulp van de HasChildNodes eigendom.

Het volgende voorbeeld van code laat zien hoe direct kind knooppunten van een CompositeNode gebruik makend van de door de ChildNodes verzameling:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
Paragraph paragraph = (Paragraph)doc.GetChild(NodeType.Paragraph, 0, true);
NodeCollection children = paragraph.ChildNodes;
foreach (Node child in children)
{
// Paragraph may contain children of various types such as runs, shapes and so on.
if (child.NodeType.Equals(NodeType.Run))
{
// Say we found the node that we want, do something useful.
Run run = (Run)child;
Console.WriteLine(run.Text);
}
}

Het volgende voorbeeld van code laat zien hoe direct kind knooppunten van een CompositeNode gebruik van geïndexeerde toegang:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
Paragraph paragraph = (Paragraph)doc.GetChild(NodeType.Paragraph, 0, true);
NodeCollection children = paragraph.ChildNodes;
for (int i = 0; i < children.Count; i++)
{
Node child = children[i];
// Paragraph may contain children of various types such as runs, shapes and so on.
if (child.NodeType.Equals(NodeType.Run))
{
// Say we found the node that we want, do something useful.
Run run = (Run)child;
Console.WriteLine(run.Text);
}
}

Verwante nodes

U kunt de knoop verkrijgen die onmiddellijk voorafgaat aan of een bepaald knooppunt volgt met behulp van de PreviousSibling en NextSibling eigenschappen, respectievelijk. Als een knooppunt is het laatste kind van zijn ouder, dan de NextSibling eigenschap is null. Omgekeerd, als de knoop is het eerste kind van zijn ouder, de PreviousSibling eigenschap is null.

Het volgende voorbeeld van code laat zien hoe je efficiënt alle directe en indirecte kindknooppunten van een samengesteld knooppunt kunt bezoeken:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public static void RecurseAllNodes()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_WorkingWithNode();
// Open a document.
Document doc = new Document(dataDir + "Node.RecurseAllNodes.doc");
// Invoke the recursive function that will walk the tree.
TraverseAllNodes(doc);
}
/// <summary>
/// A simple function that will walk through all children of a specified node recursively
/// And print the type of each node to the screen.
/// </summary>
public static void TraverseAllNodes(CompositeNode parentNode)
{
// This is the most efficient way to loop through immediate children of a node.
for (Node childNode = parentNode.FirstChild; childNode != null; childNode = childNode.NextSibling)
{
// Do some useful work.
Console.WriteLine(Node.NodeTypeToString(childNode.NodeType));
// Recurse into the node if it is a composite node.
if (childNode.IsComposite)
TraverseAllNodes((CompositeNode)childNode);
}
}

Getypte toegang tot kinder- en ouderknooppunten

Tot nu toe hebben we de eigenschappen besproken die een van de basistypen teruggeven. Node of CompositeNode. Maar soms zijn er situaties waarin je misschien waarden naar een specifieke knooppunt klasse, zoals Run of Paragraph. Dat wil zeggen, je kunt niet helemaal weg van casting bij het werken met de Aspose.Words DOM, Dat is samengesteld.

Om de behoefte aan gietgieten te verminderen, Aspose.Words klassen bieden eigenschappen en collecties die sterk getypte toegang bieden. Er zijn drie basispatronen van getypte toegang:

Getypte eigenschappen zijn slechts nuttige snelkoppelingen die soms gemakkelijker toegang bieden dan generieke eigenschappen die zijn geërfd van Node.ParentNode en CompositeNode.FirstChild.

Het volgende voorbeeld van code laat zien hoe getypte eigenschappen gebruikt kunnen worden om toegang te krijgen tot knooppunten van de documentboom:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
Section section = doc.FirstSection;
// Quick typed access to the Body child node of the Section.
Body body = section.Body;
// Quick typed access to all Table child nodes contained in the Body.
TableCollection tables = body.Tables;
foreach (Table table in tables)
{
// Quick typed access to the first row of the table.
if (table.FirstRow != null)
table.FirstRow.Remove();
// Quick typed access to the last row of the table.
if (table.LastRow != null)
table.LastRow.Remove();
}