Belgedeki Düğümler Arasındaki İçeriği Ayıkla

Belgelerle çalışırken, bir belge içindeki belirli bir aralıktan içeriği kolayca çıkarabilmek önemlidir. Ancak içerik paragraflar, tablolar, resimler vb. Gibi karmaşık öğelerden oluşabilir.

Hangi içeriğin çıkarılması gerektiğine bakılmaksızın, bu içeriği çıkarma yöntemi her zaman aralarında içerik çıkarmak için hangi düğümlerin seçileceğine göre belirlenir. Bunlar tüm metin gövdeleri veya basit metin çalıştırmaları olabilir.

İçerik ayıklarken göz önünde bulundurulması gereken birçok olası durum ve bu nedenle birçok farklı düğüm türü vardır. Örneğin, aralarında içerik ayıklamak isteyebilirsiniz:

• İki özel paragraf
• Belirli metin çalıştırmaları
• Birleştirme alanları gibi çeşitli türlerdeki alanlar
• Bir yer iminin veya yorumun başlangıç ve bitiş aralıkları
• Ayrı bölümlerde yer alan çeşitli metin gövdeleri

Bazı durumlarda, paragraf ile alan arasında veya çalışma ile yer imi arasında içerik ayıklamak gibi farklı düğüm türlerini birleştirmeniz bile gerekebilir.

Bu makalede, farklı düğümler arasında metin ayıklamak için kod uygulamasının yanı sıra yaygın senaryo örnekleri de verilmektedir.

Bu örnekler, birçok olasılığın sadece birkaç gösterisidir. Metin çıkarma işlevinin gelecekte public API’nin bir parçası olmasını planlıyoruz ve fazladan kod gerekmeyecek. Bu arada, bu işlevle ilgili isteklerinizi web sitesinde yayınlamaktan çekinmeyin. Aspose.Words forum.

Neden içeriği Ayıkla

Genellikle içeriği çıkarmanın amacı, içeriği yeni bir belgede ayrı ayrı çoğaltmak veya kaydetmektir. Örneğin, içeriği ayıklayabilir ve:

• Ayrı bir belgeye kopyalayın
• Belgenin belirli bir bölümünü PDF veya görüntüye dönüştürme
• Belgedeki içeriği birçok kez çoğaltın
• Belgenin geri kalanından ayrı olarak çıkarılan içerikle çalışın

Bu, Aspose.Words ve aşağıdaki kod uygulaması kullanılarak kolayca gerçekleştirilebilir.

İçerik Çıkarma Algoritması

Bu bölümdeki kod, yukarıda açıklanan tüm olası durumları tek bir genelleştirilmiş ve yeniden kullanılabilir yöntemle ele almaktadır. Bu tekniğin genel taslağı şunları içerir:

1. Belgenizden çıkarılacak içerik alanını belirleyen düğümleri toplamak. Bu düğümlerin alınması, kullanıcı tarafından ayıklanmak istediklerine göre kodlarında işlenir.
2. Bu düğümleri aşağıda verilen ExtractContent yöntemine geçirmek. Ayrıca, belirteç görevi gören bu düğümlerin ekstraksiyona dahil edilip edilmeyeceğini belirten bir boole parametresi de iletmelisiniz.
3. Ayıklanması belirtilen klonlanmış içeriğin (kopyalanan düğümlerin) bir listesini alma. Bu düğüm listesini, örneğin yalnızca seçilen içeriği içeren yeni bir belge oluşturmak gibi uygulanabilir herhangi bir şekilde kullanabilirsiniz.

İçerik Nasıl Çıkarılır

İçeriği belgenizden çıkarmak için aşağıdaki ExtractContent yöntemini çağırmanız ve uygun parametreleri iletmeniz gerekir. Bu yöntemin altında yatan temel, blok düzeyinde düğümler (paragraflar ve tablolar) bulmayı ve bunları aynı kopyaları oluşturmak için klonlamayı içerir. Geçirilen işaretleyici düğümler blok düzeyindeyse, yöntem içeriği o düzeydeki kopyalayıp diziye ekleyebilir.

Bununla birlikte, işaretleyici düğümler satır içi ise (bir paragrafın alt öğesi), paragrafı satır içi düğümde bölmek gerektiğinden, çalışma, yer imi alanları vb. Gibi durum daha karmaşık hale gelir. İşaretleyiciler arasında bulunmayan klonlanmış üst düğümlerdeki içerik kaldırılır. Bu işlem, satır içi düğümlerin üst paragrafın biçimlendirmesini korumaya devam etmesini sağlamak için kullanılır. Yöntem ayrıca parametre olarak geçirilen düğümler üzerinde kontroller çalıştıracak ve her iki düğüm de geçersizse bir istisna oluşturacaktır. Bu yönteme geçirilecek parametreler şunlardır:

1. StartNode ve EndNode. İlk iki parametre, içeriğin çıkarılmasının sırasıyla nerede başlayacağını ve nerede biteceğini tanımlayan düğümlerdir. Bu düğümler hem blok düzeyinde (Paragraf, Tablo) hem de satır içi düzeyde (örneğin Run, FieldStart, BookmarkStart vb.) Olabilir.):

   1. Bir alanı geçmek için karşılık gelen FieldStart nesnesini geçmelisiniz.
   2. Yer imlerini geçmek için BookmarkStart ve BookmarkEnd düğümleri geçirilmelidir.
   3. Açıklamaları iletmek için CommentRangeStart ve CommentRangeEnd düğümleri kullanılmalıdır.

2. IsInclusive. İşaretleyicilerin ekstraksiyona dahil edilip edilmediğini tanımlar. Bu seçenek false olarak ayarlanırsa ve aynı düğüm veya ardışık düğümler iletilirse, boş bir liste döndürülür:

   1. Bir FieldStart düğümü geçirilirse, bu seçenek tüm alanın dahil edilip edilmeyeceğini veya hariç tutulacağını tanımlar.
   2. Bir BookmarkStart veya BookmarkEnd düğümü iletilirse, bu seçenek yer iminin dahil edilip edilmediğini veya yalnızca yer imi aralığı arasındaki içeriği tanımlar.
   3. Bir CommentRangeStart veya CommentRangeEnd düğümü iletilirse, bu seçenek yorumun kendisinin mi yoksa yalnızca yorum aralığındaki içeriğin mi ekleneceğini tanımlar.

ExtractContent yönteminin uygulanmasını bulabilirsiniz burada. Bu yöntem, bu makaledeki senaryolarda belirtilecektir.

Ayrıca, çıkarılan düğümlerden kolayca bir belge oluşturmak için özel bir yöntem tanımlayacağız. Bu yöntem, aşağıdaki senaryoların çoğunda kullanılır ve yalnızca yeni bir belge oluşturur ve çıkarılan içeriği ona içe aktarır.

Aşağıdaki kod örneği, düğümlerin listesini nasıl alacağınızı ve bunları yeni bir belgeye nasıl ekleyeceğinizi gösterir.

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
static SharedPtr<Document> GenerateDocument(SharedPtr<Document> srcDoc, SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> nodes)
{
    auto dstDoc = MakeObject<Document>();
    // Remove the first paragraph from the empty document.
    dstDoc->get_FirstSection()->get_Body()->RemoveAllChildren();

    // Import each node from the list into the new document. Keep the original formatting of the node.
    auto importer = MakeObject<NodeImporter>(srcDoc, dstDoc, ImportFormatMode::KeepSourceFormatting);
    for (const auto& node : nodes)
    {
        SharedPtr<Node> importNode = importer->ImportNode(node, true);
        dstDoc->get_FirstSection()->get_Body()->AppendChild(importNode);
    }

    return dstDoc;
}

Paragraflar Arasında İçerik Çıkarma

Bu, belirli paragraflar arasında içerik ayıklamak için yukarıdaki yöntemin nasıl kullanılacağını gösterir. Bu durumda, belgenin ilk yarısında bulunan mektubun gövdesini çıkarmak istiyoruz. Bunun 7 ile 11. paragraflar arasında olduğunu söyleyebiliriz.

Aşağıdaki kod bu görevi yerine getirir. Uygun paragraflar, belgedeki GetChild yöntemi kullanılarak ve belirtilen endeksler geçirilerek çıkarılır. Daha sonra bu düğümleri ExtractContent yöntemine geçiririz ve bunların ekstraksiyona dahil edileceğini belirtiriz. Bu yöntem, kopyalanan içeriği bu düğümler arasında döndürür ve ardından yeni bir belgeye eklenir.

Aşağıdaki kod örneği, yukarıdaki ExtractContent yöntemini kullanarak belirli paragraflar arasındaki içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

auto startPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->get_Body()->GetChild(NodeType::Paragraph, 6, true));
auto endPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->get_Body()->GetChild(NodeType::Paragraph, 10, true));
// Extract the content between these nodes in the document. Include these markers in the extraction.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara, endPara, true);

SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenParagraphs.docx");

Farklı Düğüm Türleri Arasındaki İçeriği Ayıklayın

Blok düzeyinde veya satır içi düğümlerin herhangi bir kombinasyonu arasında içerik çıkarabiliriz. Aşağıdaki bu senaryoda, birinci paragraf ile ikinci bölümdeki tablo arasındaki içeriği kapsamlı bir şekilde çıkaracağız. Uygun Paragraf ve Tablo düğümlerini almak için belgenin ikinci bölümündeki Body.FirstParagraph ve GetChild yöntemini çağırarak işaretçi düğümlerini alırız. Küçük bir değişiklik için bunun yerine içeriği çoğaltalım ve orijinalin altına ekleyelim.

Aşağıdaki kod örneği, ExtractContent yöntemini kullanarak paragraf ve tablo arasındaki içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

auto startPara = System::ExplicitCast<Paragraph>(doc->get_LastSection()->GetChild(NodeType::Paragraph, 2, true));
auto endTable = System::ExplicitCast<Table>(doc->get_LastSection()->GetChild(NodeType::Table, 0, true));
// Extract the content between these nodes in the document. Include these markers in the extraction.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara, endTable, true);

// Let's reverse the array to make inserting the content back into the document easier.
extractedNodes->Reverse();
for (SharedPtr<Node> extractedNode : extractedNodes)        
    // Insert the last node from the reversed list.
    endTable->get_ParentNode()->InsertAfter(extractedNode, endTable);        

doc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBlockLevelNodes.docx");

Paragraflar Arasındaki İçeriği Stile Göre Ayıklayın

İçeriği, başlık stilleriyle işaretlenmiş paragraflar gibi aynı veya farklı stillerdeki paragraflar arasında ayıklamanız gerekebilir. Aşağıdaki kod bunun nasıl başarılacağını göstermektedir. Başlıkları ayıklamadan “Heading 1” ve “Header 3” stillerinin ilk örneği arasındaki içeriği ayıklayacak basit bir örnektir. Bunu yapmak için son parametreyi false olarak ayarladık, bu da işaretleyici düğümlerin dahil edilmemesi gerektiğini belirtir.

Düzgün bir uygulamada, bu, bu stillerin tüm paragrafları arasındaki içeriği belgeden çıkarmak için bir döngü içinde çalıştırılmalıdır. Çıkarılan içerik yeni bir belgeye kopyalanır.

Aşağıdaki kod örneği, ExtractContent yöntemini kullanarak belirli stillere sahip paragraflar arasında içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

// Gather a list of the paragraphs using the respective heading styles.
SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> parasStyleHeading1 = ParagraphsByStyleName(doc, u"Heading 1");
SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> parasStyleHeading3 = ParagraphsByStyleName(doc, u"Heading 3");

// Use the first instance of the paragraphs with those styles.
SharedPtr<Node> startPara1 = parasStyleHeading1->idx_get(0);
SharedPtr<Node> endPara1 = parasStyleHeading3->idx_get(0);

// Extract the content between these nodes in the document. Don't include these markers in the extraction.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara1, endPara1, false);

SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenParagraphStyles.docx");

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
static SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> ParagraphsByStyleName(SharedPtr<Document> doc, System::String styleName)
{
    // Create an array to collect paragraphs of the specified style.
    SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> paragraphsWithStyle =
        MakeObject<System::Collections::Generic::List<SharedPtr<Paragraph>>>();

    SharedPtr<NodeCollection> paragraphs = doc->GetChildNodes(NodeType::Paragraph, true);

    // Look through all paragraphs to find those with the specified style.
    for (const auto& paragraph : System::IterateOver<Paragraph>(paragraphs))
    {
        if (paragraph->get_ParagraphFormat()->get_Style()->get_Name() == styleName)
        {
            paragraphsWithStyle->Add(paragraph);
        }
    }

    return paragraphsWithStyle;
}

Belirli Çalıştırmalar Arasında İçerik Ayıkla

Run gibi satır içi düğümler arasında da içerik ayıklayabilirsiniz. Runs farklı paragraflardan işaretçi olarak geçirilebilir. Aşağıdaki kod, aynı Paragraph düğümü arasında belirli metnin nasıl çıkarılacağını gösterir.

Aşağıdaki kod örneği, ExtractContent yöntemini kullanarak aynı paragrafın belirli çalıştırmaları arasında içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

auto para = System::ExplicitCast<Paragraph>(doc->GetChild(NodeType::Paragraph, 7, true));
SharedPtr<Run> startRun = para->get_Runs()->idx_get(1);
SharedPtr<Run> endRun = para->get_Runs()->idx_get(4);

// Extract the content between these nodes in the document. Include these markers in the extraction.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startRun, endRun, true);
        
for (SharedPtr<Node> extractedNode : extractedNodes)        
    std::cout << extractedNode->ToString(SaveFormat::Text) << std::endl;

Bir Alan kullanarak içeriği Ayıklayın

Bir alanı işaretleyici olarak kullanmak için FieldStart düğümü geçirilmelidir. ExtractContent yönteminin son parametresi, tüm alanın dahil edilip edilmeyeceğini tanımlayacaktır. “FullName” birleştirme alanı ile belgedeki bir paragraf arasındaki içeriği ayıklayalım. DocumentBuilder sınıfının MoveToMergeField yöntemini kullanıyoruz. Bu, FieldStart düğümünü kendisine iletilen birleştirme alanının adından döndürür.

Bizim durumumuzda, ExtractContent yöntemine iletilen son parametreyi, alanı ayıklamadan çıkarmak için false olarak ayarlayalım. Çıkarılan içeriği PDF olarak oluşturacağız.

Aşağıdaki kod örneği, ExtractContent yöntemini kullanarak belgedeki belirli bir alan ile paragraf arasındaki içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");
auto builder = MakeObject<DocumentBuilder>(doc);

// Pass the first boolean parameter to get the DocumentBuilder to move to the FieldStart of the field.
// We could also get FieldStarts of a field using GetChildNode method as in the other examples.
builder->MoveToMergeField(u"Fullname", false, false);

// The builder cursor should be positioned at the start of the field.
auto startField = System::ExplicitCast<FieldStart>(builder->get_CurrentNode());
auto endPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->GetChild(NodeType::Paragraph, 5, true));

// Extract the content between these nodes in the document. Don't include these markers in the extraction.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startField, endPara, false);

SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentUsingField.docx");

Bir yer iminden İçerik Çıkarma

Bir belgede, yer işareti içinde tanımlanan içerik BookmarkStart ve BookmarkEnd düğümleri tarafından kapsüllenir. Bu iki düğüm arasında bulunan içerik yer imini oluşturur. Başlangıç işaretçisi belgedeki bitiş işaretçisinden önce göründüğü sürece, bu düğümlerden herhangi birini, hatta farklı yer imlerinden olanları bile herhangi bir işaretçi olarak geçirebilirsiniz. Bu içeriği aşağıdaki kodu kullanarak yeni bir belgeye çıkaracağız. IsInclusive parametre seçeneği, yer iminin nasıl saklanacağını veya silineceğini gösterir.

Aşağıdaki kod örneği, ExtractContent yöntemini kullanarak bir yer işaretine başvurulan içeriğin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

SharedPtr<Bookmark> bookmark = doc->get_Range()->get_Bookmarks()->idx_get(u"Bookmark1");
SharedPtr<BookmarkStart> bookmarkStart = bookmark->get_BookmarkStart();
SharedPtr<BookmarkEnd> bookmarkEnd = bookmark->get_BookmarkEnd();

// Firstly, extract the content between these nodes, including the bookmark.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesInclusive =
    ExtractContentHelper::ExtractContent(bookmarkStart, bookmarkEnd, true);

SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesInclusive);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBookmark.IncludingBookmark.docx");

// Secondly, extract the content between these nodes this time without including the bookmark.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesExclusive =
    ExtractContentHelper::ExtractContent(bookmarkStart, bookmarkEnd, false);

dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesExclusive);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBookmark.WithoutBookmark.docx");

Bir Yorumdan İçerik Çıkarma

Bir açıklama CommentRangeStart, CommentRangeEnd ve Yorum düğümlerinden oluşur. Bu düğümlerin tümü satır içi. İlk iki düğüm, aşağıdaki ekran görüntüsünde görüldüğü gibi, yorum tarafından başvurulan belgedeki içeriği kapsüller.

Comment düğümünün kendisi paragraflar içerebilen ve çalışabilen bir InlineStory düğümüdür. Önizleme bölmesinde yorum balonu olarak görülen yorumun mesajını temsil eder. Bu düğüm satır içi ve bir gövdenin soyundan geldiğinden, içeriği bu mesajın içinden de çıkarabilirsiniz.

Açıklama, başlığı, ilk paragrafı ve ikinci bölümdeki tabloyu kapsüller. Bu yorumu yeni bir belgeye çıkaralım. IsInclusive seçeneği, yorumun kendisinin tutulup tutulmadığını veya atılıp atılmadığını belirler.

Aşağıdaki kod örneği, bunun nasıl yapılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

auto commentStart = System::ExplicitCast<CommentRangeStart>(doc->GetChild(NodeType::CommentRangeStart, 0, true));
auto commentEnd = System::ExplicitCast<CommentRangeEnd>(doc->GetChild(NodeType::CommentRangeEnd, 0, true));

// Firstly, extract the content between these nodes including the comment as well.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesInclusive =
    ExtractContentHelper::ExtractContent(commentStart, commentEnd, true);

SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesInclusive);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenCommentRange.IncludingComment.docx");

// Secondly, extract the content between these nodes without the comment.
SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesExclusive =
    ExtractContentHelper::ExtractContent(commentStart, commentEnd, false);

dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesExclusive);
dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenCommentRange.WithoutComment.docx");

DocumentVisitor kullanarak içerik Nasıl Çıkarılır

Bu kullanım senaryosunu uygulamak için DocumentVisitor sınıfını kullanın. Bu sınıf, tanınmış Ziyaretçi tasarım modeline karşılık gelir. DocumentVisitor, ile belge ağacı üzerinde numaralandırma gerektiren özel işlemleri tanımlayabilir ve yürütebilirsiniz.

DocumentVisitor

Her DocumentVisitor.VisitXXX yöntemi, düğümlerin numaralandırılmasını denetleyen bir VisitorAction değeri döndürür. Numaralandırmaya devam etmek, geçerli düğümü atlamak (ancak numaralandırmaya devam etmek) veya düğümlerin numaralandırılmasını durdurmak isteyebilirsiniz.

Bunlar, bir belgenin çeşitli bölümlerini programlı olarak belirlemek ve ayıklamak için izlemeniz gereken adımlardır:

• DocumentVisitor ‘dan türetilmiş bir sınıf oluşturun
• Bazı özel işlemleri gerçekleştirmek için DocumentVisitor.VisitXXX yöntemlerinin bir kısmının veya tamamının uygulamalarını geçersiz kılın ve sağlayın
• Numaralandırmayı başlatmak istediğiniz düğümden Node.Accept öğesini çağırın. Örneğin, belgenin tamamını numaralandırmak istiyorsanız Document.Accept kullanın

DocumentVisitor

Bu örnek, Aspose.Words nesne modeline yeni işlemler eklemek için Ziyaretçi modelinin nasıl kullanılacağını gösterir. Bu durumda, metin biçiminde basit bir belge dönüştürücü oluştururuz:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

auto convertToPlainText = MakeObject<ExtractContent::ConvertDocToTxt>();        
// Note that every node in the object model has the accept method so the visiting
// can be executed not only for the whole document, but for any node in the document.
doc->Accept(convertToPlainText);

// Once the visiting is complete, we can retrieve the result of the operation,
// That in this example, has accumulated in the visitor.
std::cout << convertToPlainText->GetText() << std::endl;

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
/// <summary>
/// Simple implementation of saving a document in the plain text format. Implemented as a Visitor.
/// </summary>
class ConvertDocToTxt : public DocumentVisitor
{
public:
    ConvertDocToTxt() : mIsSkipText(false)
    {
        mIsSkipText = false;
        mBuilder = MakeObject<System::Text::StringBuilder>();
    }

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

    /// <summary>
    /// Called when a Run node is encountered in the document.
    /// </summary>
    VisitorAction VisitRun(SharedPtr<Run> run) override
    {
        AppendText(run->get_Text());
        // Let the visitor continue visiting other nodes.
        return VisitorAction::Continue;
    }

    /// <summary>
    /// Called when a FieldStart node is encountered in the document.
    /// </summary>
    VisitorAction VisitFieldStart(SharedPtr<FieldStart> fieldStart) override
    {
        ASPOSE_UNUSED(fieldStart);
        // In Microsoft Word, a field code (such as "MERGEFIELD FieldName") follows
        // after a field start character. We want to skip field codes and output field.
        // Result only, therefore we use a flag to suspend the output while inside a field code.
        // Note this is a very simplistic implementation and will not work very well.
        // If you have nested fields in a document.
        mIsSkipText = true;
        return VisitorAction::Continue;
    }

    /// <summary>
    /// Called when a FieldSeparator node is encountered in the document.
    /// </summary>
    VisitorAction VisitFieldSeparator(SharedPtr<FieldSeparator> fieldSeparator) override
    {
        ASPOSE_UNUSED(fieldSeparator);
        // Once reached a field separator node, we enable the output because we are
        // now entering the field result nodes.
        mIsSkipText = false;
        return VisitorAction::Continue;
    }

    /// <summary>
    /// Called when a FieldEnd node is encountered in the document.
    /// </summary>
    VisitorAction VisitFieldEnd(SharedPtr<FieldEnd> fieldEnd) override
    {
        ASPOSE_UNUSED(fieldEnd);
        // Make sure we enable the output when reached a field end because some fields
        // do not have field separator and do not have field result.
        mIsSkipText = false;
        return VisitorAction::Continue;
    }

    /// <summary>
    /// Called when visiting of a Paragraph node is ended in the document.
    /// </summary>
    VisitorAction VisitParagraphEnd(SharedPtr<Paragraph> paragraph) override
    {
        ASPOSE_UNUSED(paragraph);
        // When outputting to plain text we output Cr+Lf characters.
        AppendText(ControlChar::CrLf());
        return VisitorAction::Continue;
    }

    VisitorAction VisitBodyStart(SharedPtr<Body> body) override
    {
        ASPOSE_UNUSED(body);
        // We can detect beginning and end of all composite nodes such as Section, Body,
        // Table, Paragraph etc and provide custom handling for them.
        mBuilder->Append(u"*** Body Started ***\r\n");
        return VisitorAction::Continue;
    }

    VisitorAction VisitBodyEnd(SharedPtr<Body> body) override
    {
        ASPOSE_UNUSED(body);
        mBuilder->Append(u"*** Body Ended ***\r\n");
        return VisitorAction::Continue;
    }

    /// <summary>
    /// Called when a HeaderFooter node is encountered in the document.
    /// </summary>
    VisitorAction VisitHeaderFooterStart(SharedPtr<HeaderFooter> headerFooter) override
    {
        ASPOSE_UNUSED(headerFooter);
        // Returning this value from a visitor method causes visiting of this
        // Node to stop and move on to visiting the next sibling node
        // The net effect in this example is that the text of headers and footers
        // Is not included in the resulting output
        return VisitorAction::SkipThisNode;
    }

private:
    SharedPtr<System::Text::StringBuilder> mBuilder;
    bool mIsSkipText;

    /// <summary>
    /// Adds text to the current output. Honors the enabled/disabled output flag.
    /// </summary>
    void AppendText(String text)
    {
        if (!mIsSkipText)
        {
            mBuilder->Append(text);
        }
    }
};

Bu örneğin örnek dosyasını şu adresten indirebilirsiniz Aspose.Words GitHub.

Yalnızca Metin Nasıl Çıkarılır

Belgeden metin almanın yolları şunlardır:

• Bir dosyaya veya akışa düz metin olarak kaydetmek için Document.Save ile SaveFormat.Text kullanın
• Node.ToString kullanın ve SaveFormat.Text parametresini iletin. Dahili olarak bu, metin olarak kaydet’i bir bellek akışına çağırır ve elde edilen dizeyi döndürür
• Alan kodları da dahil olmak üzere tüm Microsoft Word kontrol karakterlerini içeren metni almak için Node.GetText kullanın
• Özelleştirilmiş çıkarma gerçekleştirmek için özel bir DocumentVisitor uygulayın

Node.GetText ve Node.ToString kullanarak

Bir Word belgesi, alan, hücre sonu, bölüm sonu vb. Gibi özel öğeleri belirten kontrol karakterleri içerebilir. Olası Sözcük denetimi karakterlerinin tam listesi ControlChar sınıfında tanımlanır. Node.GetText yöntemi, düğümde bulunan tüm denetim karakteri karakterlerinin bulunduğu metni döndürür.

ToString çağrısı, belgenin düz metin gösterimini yalnızca denetim karakterleri olmadan döndürür.

Aşağıdaki kod örneği, bir düğümde GetText ve ToString yöntemlerini çağırmak arasındaki farkı gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

builder->InsertField(u"MERGEFIELD Field");        

// When converted to text it will not retrieve fields code or special characters,
// but will still contain some natural formatting characters such as paragraph markers etc.
// This is the same as "viewing" the document as if it was opened in a text editor.
std::cout << (String(u"ToString() Result: ") + doc->ToString(SaveFormat::Text)) << std::endl;

SaveFormat.Text kullanarak

Bu örnek, belgeyi aşağıdaki gibi kaydeder:

• Alan karakterlerini ve alan kodlarını, şekli, dipnotu, sonnotu ve yorum referanslarını filtreler
• Paragraf sonu ControlChar.Cr karakterlerini ControlChar.CrLf birleşimleriyle değiştirir
• UTF8 kodlamasını kullanır

Aşağıdaki kod örneği, bir belgenin TXT biçiminde nasıl kaydedileceğini gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Document.docx");
doc->Save(ArtifactsDir + u"BaseConversions.DocxToTxt.txt");

Şekillerden Görüntüleri Ayıklayın

Bazı görevleri gerçekleştirmek için belge görüntülerini çıkarmanız gerekebilir. Aspose.Words bunu da yapmanızı sağlar.

Aşağıdaki kod örneği, bir belgeden görüntülerin nasıl çıkarılacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Images.docx");

SharedPtr<NodeCollection> shapes = doc->GetChildNodes(NodeType::Shape, true);
int imageIndex = 0;

for (const auto& shape : System::IterateOver<Shape>(shapes))
{
    if (shape->get_HasImage())
    {
        String imageFileName =
            String::Format(u"Image.ExportImages.{0}_{1}", imageIndex, FileFormatUtil::ImageTypeToExtension(shape->get_ImageData()->get_ImageType()));

        // Note, if you have only an image (not a shape with a text and the image),
        // you can use shape->GetShapeRenderer()->Save(...) method to save the image.
        shape->get_ImageData()->Save(ArtifactsDir + imageFileName);
        imageIndex++;
    }
}