Aspose.Words Belge Nesne Modeli (DOM)

Aspose.Words Belge Nesne Modeli (DOM), bir Word belgesinin bellek içi temsilidir. Aspose.Words DOM, bir Word belgesinin içeriğini ve biçimlendirmesini programlı olarak okumanıza, değiştirmenize ve değiştirmenize olanak tanır.

Bu bölümde Aspose.Words DOM’in ana sınıfları ve ilişkileri açıklanmaktadır. Aspose.Words DOM sınıflarını kullanarak belge öğelerine ve biçimlendirmeye programlı erişim elde edebilirsiniz.

Belge Nesne Ağacı Oluştur

Bir belge Aspose.Words DOM ‘e okunduğunda, bir nesne ağacı oluşturulur ve kaynak belgenin farklı türdeki öğelerinin çeşitli özelliklere sahip kendi DOM ağaç nesneleri vardır.

Belge Düğümleri Ağacı Oluştur

Aspose.Words bir Word belgesini belleğe okuduğunda, çeşitli belge öğelerini temsil eden farklı türde nesneler oluşturur. Bir metnin, paragrafın, tablonun veya bölümün her çalışması bir düğümdür ve belgenin kendisi bile bir düğümdür. Aspose.Words her belge düğümü türü için bir sınıf tanımlar.

Aspose.Words içindeki belge ağacı Bileşik Tasarım Desenini izler:

  • Tüm düğüm sınıfları nihayetinde Aspose.Words Belge Nesne Modelindeki temel sınıf olan Node sınıfından türetilir.
  • Örneğin Section veya Paragraph gibi başka düğümler içerebilen düğümler, CompositeNode sınıfından türetilir ve bu da Node sınıfından türetilir.

Aşağıda verilen diyagram, Aspose.Words Belge Nesne Modelinin (DOM) düğüm sınıfları arasındaki kalıtımı göstermektedir. Soyut sınıfların adları italiktir.

aspose-words-dom-aspose-words-cpp

Bir örneğe bakalım. Aşağıdaki resimde farklı içerik türlerine sahip bir Microsoft Word belgesi gösterilmektedir.

document-example-aspose-words-cpp

Yukarıdaki belgeyi Aspose.Words DOM ‘e okurken, aşağıdaki şemada gösterildiği gibi nesneler ağacı oluşturulur.

document-example-dom-aspose-words-cpp

Document, Section, Paragraph, Table, Shape, Run, ve diyagramdaki diğer tüm elipsler, Word belgesinin öğelerini temsil eden Aspose.Words nesnelerdir.

Bir Node Türü alın

Node sınıfı, farklı düğümleri birbirinden ayıracak kadar yeterli olsa da, Aspose.Words, belirli bir türdeki düğümleri seçmek gibi bazı API görevleri basitleştirmek için NodeType numaralandırmasını sağlar.

Her düğümün türü NodeType özelliği kullanılarak elde edilebilir. Bu özellik bir NodeType enumeration value. For example, a paragraph node represented by the Paragraph class returns NodeType.Paragraph ve Table class returns NodeType.Table ile temsil edilen bir tablo düğümü döndürür.

Aşağıdaki örnek, NodeType numaralandırmasını kullanarak bir düğüm türünün nasıl alınacağını gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
// Returns NodeType.Document
NodeType type = doc->get_NodeType();

Belge Ağacında Gezinme

Aspose.Words bir belgeyi düğümler arasında gezinmenizi sağlayan düğüm ağacı olarak temsil eder. Bu bölümde, Aspose.Words içindeki belge ağacının nasıl keşfedileceği ve gezinileceği açıklanmaktadır.

Daha önce Belge Gezgini’nde sunulan örnek belgeyi açtığınızda, düğüm ağacı tam olarak Aspose.Words içinde temsil edildiği gibi görünür.

document-in-document-explorer-aspose-words-cpp

Belge Düğümü ilişkileri

Ağaçtaki düğümlerin aralarında ilişkiler vardır:

  • Başka bir düğüm içeren bir düğüm bir parent.
  • Üst düğümde bulunan düğüm, aynı üst düğümün child. Alt düğümleri sibling düğümleridir.
  • root düğüm her zaman Document düğümdür.

Diğer düğümleri içerebilen düğümler CompositeNode sınıfından türetilir ve sonuçta tüm düğümler Node sınıfından türetilir. Bu iki temel sınıf, ağaç yapısında gezinme ve değişiklik için ortak yöntemler ve özellikler sağlar.

Aşağıdaki UML nesne diyagramı, örnek belgenin birkaç düğümünü ve bunların üst, alt ve kardeş özellikleri aracılığıyla birbirleriyle ilişkilerini gösterir:

document-nodes-relationships-aspose-words-cpp

Belge Düğüm Sahibidir

Bir düğüm, yeni oluşturulmuş veya ağaçtan kaldırılmış olsa bile her zaman belirli bir belgeye aittir, çünkü stiller ve listeler gibi hayati belge çapında yapılar Document düğümünde saklanır. Örneğin, her paragrafın belge için genel olarak tanımlanmış atanmış bir stili olduğundan, Document olmadan Paragraph olması mümkün değildir. Bu kural, yeni düğümler oluştururken kullanılır. Doğrudan DOM ‘ye yeni bir Paragraph eklemek, yapıcıya iletilen bir belge nesnesi gerektirir.

DocumentBuilder kullanarak yeni bir paragraf oluştururken, oluşturucunun her zaman DocumentBuilder.Document özelliği aracılığıyla kendisine bağlı bir Document sınıfı vardır.

Aşağıdaki kod örneği, herhangi bir düğüm oluştururken, düğüme sahip olacak bir belgenin her zaman tanımlandığını gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Open a file from disk.
System::SharedPtr<Document> doc = System::MakeObject<Document>();
// Creating a new node of any type requires a document passed into the constructor.
System::SharedPtr<Paragraph> para = System::MakeObject<Paragraph>(doc);
// The new paragraph node does not yet have a parent.
std::cout << "Paragraph has no parent node: " << System::ObjectExt::Box<bool>((para->get_ParentNode() == nullptr))->ToString().ToUtf8String() << std::endl;
// But the paragraph node knows its document.
std::cout << "Both nodes' documents are the same: " << System::ObjectExt::Box<bool>((para->get_Document() == doc))->ToString().ToUtf8String() << std::endl;
// 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->get_ParagraphFormat()->set_StyleName(u"Heading 1");
// Now add the paragraph to the main text of the first section.
doc->get_FirstSection()->get_Body()->AppendChild(para);
// The paragraph node is now a child of the Body node.
std::cout << "Paragraph has a parent node: " << System::ObjectExt::Box<bool>((para->get_ParentNode() != nullptr))->ToString().ToUtf8String() << std::endl;

Üst Düğüm

Her düğümün ParentNode özelliği tarafından belirtilen bir üst öğesi vardır. Bir düğümün ana düğümü yoktur, yani aşağıdaki durumlarda ParentNode null olur:

  • Düğüm yeni oluşturuldu ve henüz ağaca eklenmedi.
  • Düğüm ağaçtan kaldırıldı.
  • Bu, her zaman boş bir üst düğüme sahip olan kök Document düğümdür.

Remove yöntemini çağırarak bir düğümü üst öğesinden kaldırabilirsiniz.Aşağıdaki kod örneği, üst düğüme nasıl erişileceğini gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Create a new empty document. It has one section.
System::SharedPtr<Document> doc = System::MakeObject<Document>();
// The section is the first child node of the document.
System::SharedPtr<Node> section = doc->get_FirstChild();
// The section's parent node is the document.
std::cout << "Section parent is the document: " << System::ObjectExt::Box<bool>((doc == section->get_ParentNode()))->ToString().ToUtf8String() << std::endl;

Alt Düğümler

Bir CompositeNode ‘nin alt düğümlerine erişmenin en etkili yolu, sırasıyla ilk ve son alt düğümleri döndüren FirstChild ve LastChild özellikleridir. Alt düğüm yoksa, bu özellikler null döndürür.

CompositeNode

Bir düğümün alt öğesi yoksa, ChildNodes özelliği boş bir koleksiyon döndürür. CompositeNode öğesinin HasChildNodes özelliğini kullanarak herhangi bir alt düğüm içerip içermediğini kontrol edebilirsiniz.

Aşağıdaki kod örneği, ChildNodes koleksiyonu tarafından sağlanan numaralandırıcıyı kullanarak bir CompositeNode öğesinin hemen alt düğümlerinin nasıl numaralandırılacağını gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
System::SharedPtr<Paragraph> paragraph = System::DynamicCast<Paragraph>(doc->GetChild(NodeType::Paragraph, 0, true));
System::SharedPtr<NodeCollection> children = paragraph->get_ChildNodes();
for (System::SharedPtr<Node> child : System::IterateOver(children))
{
if (System::ObjectExt::Equals(child->get_NodeType(), NodeType::Run))
{
// Say we found the node that we want, do something useful.
System::SharedPtr<Run> run = System::DynamicCast<Run>(child);
std::cout << run->get_Text().ToUtf8String() << std::endl;
}
}

Aşağıdaki kod örneği, dizine eklenmiş erişimi kullanarak bir CompositeNode öğesinin hemen alt düğümlerinin nasıl numaralandırılacağını gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
System::SharedPtr<Paragraph> paragraph = System::DynamicCast<Paragraph>(doc->GetChild(NodeType::Paragraph, 0, true));
System::SharedPtr<NodeCollection> children = paragraph->get_ChildNodes();
for (int32_t i = 0; i < children->get_Count(); i++)
{
System::SharedPtr<Node> child = children->idx_get(i);
// Paragraph may contain children of various types such as runs, shapes and so on.
if (System::ObjectExt::Equals(child->get_NodeType(), NodeType::Run))
{
// Say we found the node that we want, do something useful.
System::SharedPtr<Run> run = System::DynamicCast<Run>(child);
std::cout << run->get_Text().ToUtf8String() << std::endl;
}
}

Kardeş Düğümler

Belirli bir düğümden hemen önce gelen veya onu izleyen düğümü sırasıyla PreviousSibling ve NextSibling özelliklerini kullanarak elde edebilirsiniz. Bir düğüm üst öğesinin son alt öğesiyse, NextSibling özelliği null olur. Tersine, düğüm üst öğesinin ilk alt öğesiyse, PreviousSibling özelliği null olur.

Aşağıdaki kod örneği, bir bileşik düğümün tüm doğrudan ve dolaylı alt düğümlerinin nasıl verimli bir şekilde ziyaret edileceğini gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
void TraverseAllNodes(System::SharedPtr<CompositeNode> parentNode)
{
// This is the most efficient way to loop through immediate children of a node.
for (System::SharedPtr<Node> childNode = parentNode->get_FirstChild(); childNode != nullptr; childNode = childNode->get_NextSibling())
{
// Do some useful work.
std::cout << Node::NodeTypeToString(childNode->get_NodeType()).ToUtf8String() << std::endl;
// Recurse into the node if it is a composite node.
if (childNode->get_IsComposite())
{
TraverseAllNodes(System::DynamicCast<CompositeNode>(childNode));
}
}
}
void RecurseAllNodes(System::String const &inputDataDir)
{
// Open a document.
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Node.RecurseAllNodes.doc");
// Invoke the recursive function that will walk the tree.
TraverseAllNodes(doc);
}

Alt ve Üst Düğümlere Yazılan Erişim

Şimdiye kadar, temel türlerden birini döndüren özellikleri tartıştık – Node veya CompositeNode. Ancak bazen Run veya Paragraph gibi belirli bir düğüm sınıfına değer atmanız gerekebilecek durumlar olabilir. Yani bileşik olan Aspose.Words DOM ile çalışırken dökümden tamamen kurtulamazsınız.

Döküm gereksinimini azaltmak için çoğu Aspose.Words sınıfı, kesin olarak yazılan erişim sağlayan özellikler ve koleksiyonlar sağlar. Yazılı erişimin üç temel modeli vardır:

Yazılan özellikler, bazen Node.ParentNode ve CompositeNode.FirstChild ‘dan devralınan genel özelliklerden daha kolay erişim sağlayan yalnızca kullanışlı kısayollardır.

Aşağıdaki kod örneği, belge ağacının düğümlerine erişmek için yazılan özelliklerin nasıl kullanılacağını gösterir:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
System::SharedPtr<Section> section = doc->get_FirstSection();
// Quick typed access to the Body child node of the Section.
System::SharedPtr<Body> body = section->get_Body();
// Quick typed access to all Table child nodes contained in the Body.
System::SharedPtr<TableCollection> tables = body->get_Tables();
for (System::SharedPtr<Table> table : System::IterateOver<System::SharedPtr<Table>>(tables))
{
// Quick typed access to the first row of the table.
if (table->get_FirstRow() != nullptr)
{
table->get_FirstRow()->Remove();
}
// Quick typed access to the last row of the table.
if (table->get_LastRow() != nullptr)
{
table->get_LastRow()->Remove();
}
}