Estrai contenuto tra i nodi in un documento

Quando si lavora con i documenti, è importante poter estrarre facilmente il contenuto da un intervallo specifico all’interno di un documento. Tuttavia, il contenuto può essere costituito da elementi complessi come paragrafi, tabelle, immagini, ecc.

Indipendentemente dal contenuto che deve essere estratto, il metodo per estrarre tale contenuto sarà sempre determinato da quali nodi vengono selezionati per estrarre il contenuto. Possono trattarsi di interi corpi di testo o di semplici sequenze di testo.

Esistono molte situazioni possibili e quindi molti tipi di nodi diversi da considerare durante l’estrazione del contenuto. Ad esempio, potresti voler estrarre il contenuto tra:

  • Due paragrafi specifici
  • Sequenze di testo specifiche
  • Campi di vario tipo, ad esempio campi di unione
  • Intervalli iniziali e finali di un segnalibro o commento
  • Vari corpi di testo contenuti in sezioni separate

In alcune situazioni, potrebbe anche essere necessario combinare diversi tipi di nodo, ad esempio per estrarre il contenuto tra un paragrafo e un campo o tra un’esecuzione e un segnalibro.

Questo articolo fornisce l’implementazione del codice per l’estrazione del testo tra nodi diversi, nonché esempi di scenari comuni.

Perché estrarre contenuti

Spesso l’obiettivo dell’estrazione del contenuto è duplicarlo o salvarlo separatamente in un nuovo documento. Ad esempio, puoi estrarre contenuti e:

  • Copialo in un documento separato
  • Converti una parte specifica di un documento in PDF o immagine
  • Duplicare più volte il contenuto del documento
  • Lavora con il contenuto estratto separato dal resto del documento

Ciò può essere facilmente ottenuto utilizzando Aspose.Words e l’implementazione del codice seguente.

Algoritmo di estrazione del contenuto

Il codice in questa sezione affronta tutte le possibili situazioni descritte sopra con un metodo generalizzato e riutilizzabile. Lo schema generale di questa tecnica prevede:

  1. Raccogliere i nodi che determinano l’area di contenuto che verrà estratta dal tuo documento. Il recupero di questi nodi viene gestito dall’utente nel proprio codice, in base a ciò che desidera estrarre.
  2. Passando questi nodi al metodo ExtractContent fornito di seguito. È inoltre necessario passare un parametro booleano che indichi se questi nodi, che fungono da marcatori, devono essere inclusi o meno nell’estrazione.
  3. Recupero di un elenco di contenuto clonato (nodi copiati) specificato da estrarre. È possibile utilizzare questo elenco di nodi in qualsiasi modo applicabile, ad esempio creando un nuovo documento contenente solo il contenuto selezionato.

Come estrarre il contenuto

Per estrarre il contenuto dal tuo documento devi chiamare il metodo ExtractContent di seguito e passare i parametri appropriati. La base di questo metodo prevede la ricerca di nodi a livello di blocco (paragrafi e tabelle) e la loro clonazione per creare copie identiche. Se i nodi marcatori passati sono a livello di blocco, il metodo è in grado semplicemente di copiare il contenuto su quel livello e aggiungerlo all’array.

Tuttavia, se i nodi marcatori sono in linea (un figlio di un paragrafo), la situazione diventa più complessa, poiché è necessario dividere il paragrafo nel nodo in linea, che si tratti di una sequenza, di campi di segnalibri, ecc. Il contenuto nei nodi principali clonati non presente tra i marcatori viene rimosso. Questo processo viene utilizzato per garantire che i nodi in linea mantengano comunque la formattazione del paragrafo principale. Il metodo eseguirà inoltre controlli sui nodi passati come parametri e genererà un’eccezione se uno dei nodi non è valido. I parametri da passare a questo metodo sono:

  1. StartNode e EndNode. I primi due parametri sono i nodi che definiscono rispettivamente dove deve iniziare e dove deve finire l’estrazione del contenuto. Questi nodi possono essere sia a livello di blocco (Paragraph, Table) che a livello inline (es. Run, FieldStart, BookmarkStart ecc.):
    1. Per passare un campo è necessario passare l’oggetto FieldStart corrispondente
    2. Per passare i segnalibri, è necessario passare i nodi BookmarkStart e BookmarkEnd
    3. Per passare commenti, è necessario utilizzare i nodi CommentRangeStart e CommentRangeEnd
  2. IsInclusive. Definisce se i marcatori sono inclusi nell’estrazione oppure no. Se questa opzione è impostata su false e vengono passati lo stesso nodo o nodi consecutivi, verrà restituito un elenco vuoto:
    1. Se viene passato un nodo FieldStart, questa opzione definisce se l’intero campo deve essere incluso o escluso
    2. Se viene passato un nodo BookmarkStart o BookmarkEnd, questa opzione definisce se il segnalibro è incluso o solo il contenuto nell’intervallo di segnalibri.
    3. Se viene passato un nodo CommentRangeStart o CommentRangeEnd, questa opzione definisce se deve essere incluso il commento stesso o solo il contenuto nell’intervallo dei commenti.

L’implementazione del metodo ExtractContent puoi trovare su Aspose.Words GitHub. Questo metodo verrà fatto riferimento negli scenari in questo articolo.

Definiremo anche un metodo personalizzato per generare facilmente un documento dai nodi estratti. Questo metodo viene utilizzato in molti degli scenari seguenti e crea semplicemente un nuovo documento e vi importa il contenuto estratto.

Il seguente esempio di codice mostra come prendere un elenco di nodi e inserirli in un nuovo documento:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
public static Document GenerateDocument(Document srcDoc, List<Node> nodes)
{
Document dstDoc = new Document();
// Remove the first paragraph from the empty document.
dstDoc.FirstSection.Body.RemoveAllChildren();
// Import each node from the list into the new document. Keep the original formatting of the node.
NodeImporter importer = new NodeImporter(srcDoc, dstDoc, ImportFormatMode.KeepSourceFormatting);
foreach (Node node in nodes)
{
Node importNode = importer.ImportNode(node, true);
dstDoc.FirstSection.Body.AppendChild(importNode);
}
return dstDoc;
}

Estrai contenuto tra paragrafi

Questo dimostra come utilizzare il metodo sopra per estrarre il contenuto tra paragrafi specifici. In questo caso vogliamo estrarre il corpo della lettera che si trova nella prima metà del documento. Possiamo dire che questo è tra il 7° e l'11° paragrafo.

Il codice seguente esegue questa attività. I paragrafi appropriati vengono estratti utilizzando il metodo GetChild sul documento e passando gli indici specificati. Passiamo quindi questi nodi al metodo ExtractContent e stabiliamo che questi siano da includere nell’estrazione. Questo metodo restituirà il contenuto copiato tra questi nodi che verranno poi inseriti in un nuovo documento.

Il seguente esempio di codice mostra come estrarre il contenuto tra paragrafi specifici utilizzando il metodo ExtractContent sopra:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
Paragraph startPara = (Paragraph) doc.FirstSection.Body.GetChild(NodeType.Paragraph, 6, true);
Paragraph endPara = (Paragraph) doc.FirstSection.Body.GetChild(NodeType.Paragraph, 10, true);
// Extract the content between these nodes in the document. Include these markers in the extraction.
List<Node> extractedNodes = ExtractContentHelper.ExtractContent(startPara, endPara, true);
Document dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodes);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenParagraphs.docx");

Estrai contenuto tra diversi tipi di nodi

Possiamo estrarre il contenuto tra qualsiasi combinazione di livello di blocco o nodi in linea. In questo scenario di seguito estrarremo il contenuto tra il primo paragrafo e la tabella nella seconda sezione in modo inclusivo. Otteniamo i nodi dei marcatori chiamando i metodi FirstParagraph e GetChild nella seconda sezione del documento per recuperare i nodi Paragraph e Table appropriati. Per una leggera variazione duplichiamo invece il contenuto e inseriamolo sotto l’originale.

L’esempio di codice seguente mostra come estrarre il contenuto tra un paragrafo e una tabella utilizzando il metodo ExtractContent:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
Paragraph startPara = (Paragraph) doc.LastSection.GetChild(NodeType.Paragraph, 2, true);
Table endTable = (Table) doc.LastSection.GetChild(NodeType.Table, 0, true);
// Extract the content between these nodes in the document. Include these markers in the extraction.
List<Node> extractedNodes = ExtractContentHelper.ExtractContent(startPara, endTable, true);
// Let's reverse the array to make inserting the content back into the document easier.
extractedNodes.Reverse();
foreach (Node extractedNode in extractedNodes)
endTable.ParentNode.InsertAfter(extractedNode, endTable);
doc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenBlockLevelNodes.docx");

Estrai il contenuto tra i paragrafi in base allo stile

Potrebbe essere necessario estrarre il contenuto tra paragrafi con stile uguale o diverso, ad esempio tra paragrafi contrassegnati con stili di titolo. Il codice seguente mostra come ottenere questo risultato. È un semplice esempio che estrarrà il contenuto tra la prima istanza degli stili “Intestazione 1” e “Intestazione 3” senza estrarre anche i titoli. Per fare ciò impostiamo l’ultimo parametro su false, che specifica che i nodi marcatori non devono essere inclusi.

In un’implementazione corretta, questo dovrebbe essere eseguito in loop per estrarre il contenuto tra tutti i paragrafi di questi stili dal documento. Il contenuto estratto viene copiato in un nuovo documento.

Il seguente esempio di codice mostra come estrarre il contenuto tra i paragrafi con stili specifici utilizzando il metodo ExtractContent:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
// Gather a list of the paragraphs using the respective heading styles.
List<Paragraph> parasStyleHeading1 = ParagraphsByStyleName(doc, "Heading 1");
List<Paragraph> parasStyleHeading3 = ParagraphsByStyleName(doc, "Heading 3");
// Use the first instance of the paragraphs with those styles.
Node startPara = parasStyleHeading1[0];
Node endPara = parasStyleHeading3[0];
// Extract the content between these nodes in the document. Don't include these markers in the extraction.
List<Node> extractedNodes = ExtractContentHelper.ExtractContent(startPara, endPara, false);
Document dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodes);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenParagraphStyles.docx");
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
public List<Paragraph> ParagraphsByStyleName(Document doc, string styleName)
{
// Create an array to collect paragraphs of the specified style.
List<Paragraph> paragraphsWithStyle = new List<Paragraph>();
NodeCollection paragraphs = doc.GetChildNodes(NodeType.Paragraph, true);
// Look through all paragraphs to find those with the specified style.
foreach (Paragraph paragraph in paragraphs)
{
if (paragraph.ParagraphFormat.Style.Name == styleName)
paragraphsWithStyle.Add(paragraph);
}
return paragraphsWithStyle;
}

Estrai contenuto tra esecuzioni specifiche

Puoi anche estrarre contenuto tra nodi in linea come un Run. Runs di paragrafi diversi possono essere passati come marcatori. Il codice seguente mostra come estrarre testo specifico tra lo stesso nodo Paragraph.

L’esempio di codice seguente mostra come estrarre il contenuto tra esecuzioni specifiche dello stesso paragrafo utilizzando il metodo ExtractContent:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
Paragraph para = (Paragraph) doc.GetChild(NodeType.Paragraph, 7, true);
Run startRun = para.Runs[1];
Run endRun = para.Runs[4];
// Extract the content between these nodes in the document. Include these markers in the extraction.
List<Node> extractedNodes = ExtractContentHelper.ExtractContent(startRun, endRun, true);
foreach (Node extractedNode in extractedNodes)
Console.WriteLine(extractedNode.ToString(SaveFormat.Text));

Estrai contenuto utilizzando un campo

Per utilizzare un campo come marcatore, è necessario passare il nodo FieldStart. L’ultimo parametro del metodo ExtractContent definirà se l’intero campo deve essere incluso o meno. Estraiamo il contenuto tra il campo di unione “FullName” e un paragrafo nel documento. Usiamo il metodo MoveToMergeField della classe DocumentBuilder. Ciò restituirà il nodo FieldStart dal nome del campo di unione passato ad esso.

Nel nostro caso impostiamo l’ultimo parametro passato al metodo ExtractContent su false per escludere il campo dall’estrazione. Renderemo il contenuto estratto in PDF.

Il seguente esempio di codice mostra come estrarre il contenuto tra un campo e un paragrafo specifici nel documento utilizzando il metodo ExtractContent:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
DocumentBuilder builder = new 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("Fullname", false, false);
// The builder cursor should be positioned at the start of the field.
FieldStart startField = (FieldStart) builder.CurrentNode;
Paragraph endPara = (Paragraph) doc.FirstSection.GetChild(NodeType.Paragraph, 5, true);
// Extract the content between these nodes in the document. Don't include these markers in the extraction.
List<Node> extractedNodes = ExtractContentHelper.ExtractContent(startField, endPara, false);
Document dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodes);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentUsingField.docx");

Estrai contenuto da un segnalibro

In un documento il contenuto definito all’interno di un segnalibro viene incapsulato dai nodi BookmarkStart e BookmarkEnd. Il contenuto trovato tra questi due nodi costituisce il segnalibro. Puoi passare uno di questi nodi come qualsiasi marcatore, anche quelli di segnalibri diversi, purché il marcatore di inizio appaia prima del marcatore di fine nel documento. Estrarremo questo contenuto in un nuovo documento utilizzando il codice seguente. L’opzione del parametro IsInclusive mostra come conservare o eliminare il segnalibro.

L’esempio di codice seguente mostra come estrarre il contenuto a cui fa riferimento un segnalibro utilizzando il metodo ExtractContent:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
Bookmark bookmark = doc.Range.Bookmarks["Bookmark1"];
BookmarkStart bookmarkStart = bookmark.BookmarkStart;
BookmarkEnd bookmarkEnd = bookmark.BookmarkEnd;
// Firstly, extract the content between these nodes, including the bookmark.
List<Node> extractedNodesInclusive = ExtractContentHelper.ExtractContent(bookmarkStart, bookmarkEnd, true);
Document dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodesInclusive);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenBookmark.IncludingBookmark.docx");
// Secondly, extract the content between these nodes this time without including the bookmark.
List<Node> extractedNodesExclusive = ExtractContentHelper.ExtractContent(bookmarkStart, bookmarkEnd, false);
dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodesExclusive);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenBookmark.WithoutBookmark.docx");

Estrai contenuto da un commento

Un commento è costituito dai nodi CommentRangeStart, CommentRangeEnd e Comment. Tutti questi nodi sono in linea. I primi due nodi incapsulano il contenuto del documento a cui fa riferimento il commento, come mostrato nello screenshot seguente.

Il nodo Comment stesso è un InlineStory che può contenere paragrafi e sequenze. Rappresenta il messaggio del commento visualizzato come un fumetto nel riquadro di revisione. Poiché questo nodo è in linea e discendente di un corpo, puoi anche estrarre il contenuto anche dall’interno di questo messaggio.

Il commento incapsula l’intestazione, il primo paragrafo e la tabella nella seconda sezione. Estraiamo questo commento in un nuovo documento. L’opzione IsInclusive determina se il commento stesso viene mantenuto o scartato.

L’esempio di codice seguente mostra come eseguire questa operazione:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
CommentRangeStart commentStart = (CommentRangeStart) doc.GetChild(NodeType.CommentRangeStart, 0, true);
CommentRangeEnd commentEnd = (CommentRangeEnd) doc.GetChild(NodeType.CommentRangeEnd, 0, true);
// Firstly, extract the content between these nodes including the comment as well.
List<Node> extractedNodesInclusive = ExtractContentHelper.ExtractContent(commentStart, commentEnd, true);
Document dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodesInclusive);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenCommentRange.IncludingComment.docx");
// Secondly, extract the content between these nodes without the comment.
List<Node> extractedNodesExclusive = ExtractContentHelper.ExtractContent(commentStart, commentEnd, false);
dstDoc = ExtractContentHelper.GenerateDocument(doc, extractedNodesExclusive);
dstDoc.Save(ArtifactsDir + "ExtractContent.ExtractContentBetweenCommentRange.WithoutComment.docx");

Come estrarre contenuto utilizzando DocumentVisitor

Utilizzare la classe DocumentVisitor per implementare questo scenario di utilizzo. Questa classe corrisponde al noto modello di progettazione Visitor. Con DocumentVisitor , puoi definire ed eseguire operazioni personalizzate che richiedono l’enumerazione nell’albero del documento.

DocumentVisitor fornisce una serie di metodi VisitXXX che vengono richiamati quando viene incontrato un particolare elemento del documento (nodo). Ad esempio, VisitParagraphStart viene chiamato quando viene trovato l’inizio di un paragrafo di testo e VisitParagraphEnd viene chiamato quando viene trovata la fine di un paragrafo di testo. Ogni metodo DocumentVisitor.VisitXXX accetta l’oggetto corrispondente che incontra in modo da poterlo utilizzare secondo necessità (ad esempio recuperare la formattazione), ad esempio sia DocumentVisitor.VisitParagraphStart che DocumentVisitor.VisitParagraphEnd accettano un oggetto Paragraph.

Ogni metodo DocumentVisitor.VisitXXX restituisce un valore VisitorAction che controlla l’enumerazione dei nodi. È possibile richiedere di continuare l’enumerazione, saltare il nodo corrente (ma continuare l’enumerazione) o interrompere l’enumerazione dei nodi.

Questi sono i passaggi da seguire per determinare ed estrarre a livello di codice varie parti di un documento:

  • Crea una classe derivata da DocumentVisitor
  • Sostituisci e fornisci implementazioni per alcuni o tutti i metodi DocumentVisitor.VisitXXX per eseguire alcune operazioni personalizzate
  • Richiama Node.Accept sul nodo da cui vuoi iniziare l’enumerazione, ad esempio, se vuoi enumerare l’intero documento, usa Document.Accept

DocumentVisitor fornisce implementazioni predefinite per tutti i metodi DocumentVisitor.VisitXXX. Ciò semplifica la creazione di nuovi visitatori del documento poiché è necessario sovrascrivere solo i metodi richiesti per il visitatore specifico. Non è necessario sovrascrivere tutti i metodi del visitatore.

Nell’esempio seguente viene illustrato come utilizzare il modello Visitor per aggiungere nuove operazioni al modello a oggetti Aspose.Words. In questo caso, creiamo un semplice convertitore di documenti in formato testo:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Extract content.docx");
ConvertDocToTxt convertToPlainText = new 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.
Console.WriteLine(convertToPlainText.GetText());
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
/// <summary>
/// Simple implementation of saving a document in the plain text format. Implemented as a Visitor.
/// </summary>
internal class ConvertDocToTxt : DocumentVisitor
{
public ConvertDocToTxt()
{
mIsSkipText = false;
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 Run node is encountered in the document.
/// </summary>
public override VisitorAction VisitRun(Run run)
{
AppendText(run.Text);
// Let the visitor continue visiting other nodes.
return VisitorAction.Continue;
}
/// <summary>
/// Called when a FieldStart node is encountered in the document.
/// </summary>
public override VisitorAction VisitFieldStart(FieldStart 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>
public override VisitorAction VisitFieldSeparator(FieldSeparator 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>
public override VisitorAction VisitFieldEnd(FieldEnd 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>
public override VisitorAction VisitParagraphEnd(Paragraph paragraph)
{
// When outputting to plain text we output Cr+Lf characters.
AppendText(ControlChar.CrLf);
return VisitorAction.Continue;
}
public override VisitorAction VisitBodyStart(Body 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("*** Body Started ***\r\n");
return VisitorAction.Continue;
}
public override VisitorAction VisitBodyEnd(Body body)
{
mBuilder.Append("*** Body Ended ***\r\n");
return VisitorAction.Continue;
}
/// <summary>
/// Called when a HeaderFooter node is encountered in the document.
/// </summary>
public override VisitorAction VisitHeaderFooterStart(HeaderFooter 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;
}
/// <summary>
/// Adds text to the current output. Honors the enabled/disabled output flag.
/// </summary>
private void AppendText(string text)
{
if (!mIsSkipText)
mBuilder.Append(text);
}
private readonly StringBuilder mBuilder;
private bool mIsSkipText;
}

Come estrarre solo testo

I modi per recuperare il testo dal documento sono:

  • Utilizza Document.Save con SaveFormat.Text per salvare come testo normale in un file o flusso
  • Usa Node.ToString e passa il parametro SaveFormat.Text. Internamente, richiama il salvataggio come testo in un flusso di memoria e restituisce la stringa risultante
  • Utilizza Node.GetText per recuperare il testo con tutti i caratteri di controllo Microsoft Word inclusi i codici di campo
  • Implementare un DocumentVisitor personalizzato per eseguire un’estrazione personalizzata

Utilizzando Node.GetText e Node.ToString

Un documento Word può contenere caratteri di controllo che designano elementi speciali come campo, fine di cella, fine di sezione ecc. L’elenco completo dei possibili caratteri di controllo di Word è definito nella classe ControlChar. Il metodo Node.GetText restituisce il testo con tutti i caratteri di controllo presenti nel nodo.

La chiamata a ToString restituisce la rappresentazione in testo semplice del documento solo senza caratteri di controllo. Per ulteriori informazioni sull’esportazione come testo semplice vedere la sezione successiva “Utilizzo di SaveFormat.Text”.

L’esempio di codice seguente mostra la differenza tra la chiamata dei metodi GetText e ToString su un nodo:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.InsertField("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.
Console.WriteLine("Convert to text result: " + doc.ToString(SaveFormat.Text));

Utilizzando SaveFormat.Text

Questo esempio salva il documento come segue:

  • Filtra caratteri di campo e codici di campo, forme, note a piè di pagina, note di chiusura e riferimenti a commenti
  • Sostituisce i caratteri ControlChar.Cr di fine paragrafo con combinazioni ControlChar.CrLf
  • Utilizza la codifica UTF8

Il seguente esempio di codice mostra come salvare un documento in formato TXT:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Document.docx");
doc.Save(ArtifactsDir + "BaseConversions.DocxToTxt.txt");
view raw docx-to-txt.cs hosted with ❤ by GitHub

Estrai immagini da forme

Potrebbe essere necessario estrarre le immagini dei documenti per eseguire alcune attività. Aspose.Words ti consente di fare anche questo.

Il seguente esempio di codice mostra come estrarre immagini da un documento:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Images.docx");
NodeCollection shapes = doc.GetChildNodes(NodeType.Shape, true);
int imageIndex = 0;
foreach (Shape shape in shapes)
{
if (shape.HasImage)
{
string imageFileName =
$"Image.ExportImages.{imageIndex}_{FileFormatUtil.ImageTypeToExtension(shape.ImageData.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.ImageData.Save(ArtifactsDir + imageFileName);
imageIndex++;
}
}