Aspose.Words Dokument Voorwerp Model (DOM)
Die Aspose.Words Document Object Model (DOM) is’n in-geheue voorstelling van’n Word dokument. Met die Aspose.Words DOM kan u die inhoud en formatering van’n Word-dokument programmaties lees, manipuleer en verander.
Hierdie afdeling beskryf die hoofklasse van die Aspose.Words DOM en hul verhoudings. Deur die Aspose.Words DOM klasse te gebruik, kan jy programmatiese toegang tot dokumentelemente en formatering verkry.
Skep’n Document
Voorwerp Boom
Wanneer’n dokument in die Aspose.Words DOM gelees word, dan word’n voorwerp boom gebou en verskillende tipes elemente van die bron dokument het hul eie DOM boom voorwerpe met verskillende eienskappe.
Bou Dokument Nodes Boom
Wanneer Aspose.Words ‘n Word-dokument in die geheue lees, skep dit voorwerpe van verskillende tipes wat verskillende dokumentelemente verteenwoordig. Elke reeks van’n teks, paragraaf, tabel, of’n afdeling is’n knoop, en selfs die dokument self is’n knoop. Aspose.Words definieer’n klas vir elke dokument node tipe.
Die dokument boom in Aspose.Words volg die Saamgestelde Ontwerp Patroon:
- Alle knoop klasse uiteindelik afgelei van die Node klas, wat is die basis klas in die Aspose.Words Dokument Voorwerp Model.
- Knope wat ander knope kan bevat, byvoorbeeld Section of Paragraph, is afgelei van die CompositeNode klas, wat op sy beurt afgelei is van die Node klas.
Die diagram hieronder toon oorerwing tussen knoop klasse van die Aspose.Words Dokument Voorwerp Model (DOM). Die name van abstrakte klasse is in Kursief.
Node
klas.
Kom ons kyk na’n voorbeeld. Die volgende prent toon’n Microsoft Word dokument met verskillende soorte inhoud.
Wanneer die bogenoemde dokument in die Aspose.Words DOM gelees word, word die boom van voorwerpe geskep, soos in die skema hieronder getoon.
Document, Section, Paragraph, Table, Shape, Run, en al die ander ellipses op die diagram is Aspose.Words voorwerpe wat elemente van die Word-dokument verteenwoordig.
Kry’n Node
Tipe
Alhoewel die Node klas voldoende is om verskillende nodusse van mekaar te onderskei, bied Aspose.Words die NodeType opsomming om sommige API take te vereenvoudig, soos die keuse van nodusse van’n spesifieke tipe.
Die tipe van elke knoop kan verkry word deur die NodeType eienskap te gebruik. Hierdie eienskap gee’n NodeType opsomming waarde. Byvoorbeeld, ‘n paragraaf knoop verteenwoordig deur die Paragraph klas gee terug NodeType.Paragraph, en’n tabel knoop verteenwoordig deur die Table klas gee terug NodeType.Table.
Die volgende voorbeeld toon hoe om’n knoop tipe te kry met behulp van die NodeType opsomming:
// 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; |
Dokument Boom Navigasie
Aspose.Words verteenwoordig’n dokument as’n node boom, wat jou in staat stel om te navigeer tussen nodes. Hierdie afdeling beskryf hoe om die dokument boom in Aspose.Words te verken en te navigeer.
As u die voorbeelddokument oopmaak, wat vroeër in Die Document Explorer aangebied is, verskyn die knoopboom presies soos dit in Aspose.Words voorgestel word.
Dokument Node Verhoudings
Die nodusse in die boom het verhoudings tussen hulle:
- ‘n node wat’n ander node bevat is’n parent.
- Die knoop wat in die ouer knoop is’n child. Kind nodes van dieselfde ouer is sibling nodes.
- Die root knoop is altyd die Document knoop.
Die nodusse wat ander nodusse kan bevat, is afgelei van die CompositeNode klas, en alle nodusse is uiteindelik afgelei van die Node klas. Hierdie twee basis klasse bied gemeenskaplike metodes en eienskappe vir die boom struktuur navigasie en verandering.
Die volgende UML voorwerp diagram toon verskeie nodusse van die voorbeeld dokument en hul verhoudings met mekaar via die ouer, kind, en broer eienskappe:
Dokument Is Node Eienaar
‘n knoppie behoort altyd aan’n spesifieke dokument, selfs al is dit net geskep of verwyder uit die boom, omdat belangrike dokument-wye strukture soos style en lyste in die Document knoppie gestoor word. Dit is byvoorbeeld nie moontlik om’n Paragraph sonder’n Document te hê nie, want elke paragraaf het’n toegewyde styl wat wêreldwyd vir die dokument gedefinieer is. Hierdie reël word gebruik wanneer enige nuwe nodusse geskep word. Die toevoeging van’n nuwe Paragraph direk aan die DOM vereis’n dokument voorwerp wat aan die konstruktor.
Wanneer die skep van’n nuwe paragraaf met behulp van DocumentBuilder, die bouer het altyd’n Document klas gekoppel aan dit deur die DocumentBuilder.Document eiendom.
Die volgende kode voorbeeld toon dat wanneer die skep van enige node, ‘n dokument wat die node sal besit altyd gedefinieer:
// 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)); |
Ouerknooppunt
Elke knoop het’n ouer wat deur die ParentNode eienskap gespesifiseer word. ‘n knoppie het geen ouer knoppie nie, dit wil sê, ParentNode is nul, in die volgende gevalle:
- Die knoop is pas geskep en is nog nie by die boom gevoeg nie.
- Die knoop is van die boom verwyder.
- Dit is die wortel Document knoop wat altyd’n nul ouer knoop het.
Jy kan’n knoop van sy ouer verwyder deur die Remove metode te bel.Die volgende kode voorbeeld toon hoe om toegang tot die ouer node:
// 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)); |
Kind Knope
Die mees doeltreffende manier om toegang tot kind nodes van a CompositeNode is via die FirstChild en LastChild eienskappe wat die eerste en laaste kind nodes, onderskeidelik terugkeer. As daar geen kind nodes, hierdie eienskappe terugkeer null.
CompositeNode
As’n knoop geen kind het nie, dan gee die ChildNodes eienskap’n leë versameling terug. Jy kan kyk of die CompositeNode bevat enige kind nodes met behulp van die HasChildNodes eiendom.
Die volgende kode voorbeeld toon hoe om onmiddellike kind nodes van a CompositeNode
te tel met behulp van die enumerator wat deur die ChildNodes
versameling:
// 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); | |
} | |
} |
Die volgende kode voorbeeld toon hoe om onmiddellike kind nodes van’n CompositeNode
te tel met behulp van geïndekseerde 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); | |
} | |
} |
Broersknope
Jy kan die knoop wat onmiddellik voorafgaan of volg’n bepaalde knoop met behulp van die PreviousSibling en NextSibling eienskappe, onderskeidelik. As’n knoop die laaste kind van sy ouer is, dan is die NextSibling eienskap null. Omgekeerd, as die knoop die eerste kind van sy ouer is, is die PreviousSibling eienskap null.
Die volgende kode voorbeeld toon hoe om doeltreffend te besoek al direkte en indirekte kind nodes van’n saamgestelde node:
// 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); | |
} | |
} |
Getikte Toegang Tot Kind En Ouer Nodes
Tot dusver het ons die eienskappe bespreek wat een van die basis tipes – Node of CompositeNode teruggee. Maar soms is daar situasies waar jy dalk waardes moet gooi na’n spesifieke knoop klas, soos Run of Paragraph. Dit wil sê, jy kan nie heeltemal wegkom van giet wanneer jy met die Aspose.Words DOM werk nie, wat saamgestel is.
Om die behoefte aan giet te verminder, die meeste Aspose.Words klasse bied eienskappe en versamelings wat sterk getik toegang bied. Daar is drie basiese patrone van getikte toegang:
- ‘n ouer-knooppunt stel getypte FirstXXX en LastXXX eienskappe bloot. Byvoorbeeld, die Document het FirstSection en LastSection eienskappe. Net so het Table eienskappe soos FirstRow, LastRow, en ander.
- ‘n ouer-knooppunt stel’n getypte versameling van kind-knooppunte bloot, soos Document.Sections, Body.Paragraphs, en ander.
- ‘n kind-knooppunt bied getikte toegang tot sy ouer, soos Run.ParentParagraph, Paragraph.ParentSection, en ander.
Getypeerde eienskappe is bloot nuttige kortpaaie wat soms makliker toegang bied as generiese eienskappe wat van Node.ParentNode en CompositeNode.FirstChild geërf word.
Die volgende kode voorbeeld toon hoe om getik eienskappe gebruik om toegang tot nodes van die dokument boom:
// 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(); | |
} |