Confronta documenti

Il confronto dei documenti è un processo che identifica le modifiche tra due documenti e contiene le modifiche come revisioni. Questo processo confronta due documenti qualsiasi, comprese le versioni di un documento specifico, quindi le modifiche tra entrambi i documenti verranno visualizzate come revisioni nel primo documento.

Il metodo di confronto si ottiene confrontando le parole a livello di carattere o a livello di parola. Se una parola contiene una modifica di almeno un carattere, nel risultato la differenza verrà visualizzata come una modifica dell’intera parola e non di un carattere. Questo processo di confronto è un compito abituale nei settori legale e finanziario.

Invece di cercare manualmente le differenze tra documenti o tra diverse versioni degli stessi, puoi utilizzare Aspose.Words per confrontare documenti e ottenere modifiche al contenuto nella formattazione, intestazione/piè di pagina, tabelle e altro.

Questo articolo spiega come confrontare i documenti e come specificare le proprietà di confronto avanzate.

Prova on-line

Puoi confrontare due documenti online utilizzando lo strumento Confronto di documenti online.

Tieni presente che il metodo di confronto, descritto di seguito, viene utilizzato in questo strumento per garantire l’ottenimento di risultati uguali. Quindi otterrai gli stessi risultati anche utilizzando lo strumento di confronto online o utilizzando il metodo di confronto in Aspose.Words.

Limitazioni e formati di file supportati

Il confronto dei documenti è una funzionalità molto complessa. Esistono varie parti della combinazione di contenuti che devono essere analizzate per riconoscere tutte le differenze. Il motivo di questa complessità è dovuto al fatto che Aspose.Words mira a ottenere gli stessi risultati di confronto dell’algoritmo di confronto Microsoft Word.

La limitazione generale per due documenti da confrontare è che non devono avere revisioni prima di chiamare il metodo di confronto poiché questa limitazione esiste in Microsoft Word.

Tieni presente che puoi confrontare due documenti qualsiasi all’interno del Formati di documenti supportati. Fondamentalmente, puoi confrontare gli oggetti del documento e persino creare quegli oggetti da zero senza avere alcun formato specifico.

Confronta due documenti

Quando si confrontano i documenti, le differenze tra il secondo e il primo vengono visualizzate come revisioni del primo. Quando modifichi un documento, ogni modifica avrà la propria revisione dopo aver eseguito il metodo di confronto.

Aspose.Words ti consente di identificare le differenze tra i documenti utilizzando il metodo Compare: è simile alla funzione di confronto dei documenti Microsoft Word. Ti consente di controllare documenti o versioni di documenti per trovare differenze e modifiche, comprese modifiche alla formattazione come modifiche ai caratteri, modifiche alla spaziatura, aggiunta di parole e paragrafi.

Come risultato del confronto, i documenti possono essere determinati come uguali o non uguali. Il termine documenti “uguali” significa che il metodo di confronto non è in grado di rappresentare le modifiche come revisioni. Ciò significa che sia il testo del documento che la formattazione del testo sono gli stessi. Ma possono esserci altre differenze tra i documenti. Ad esempio, Microsoft Word supporta solo le revisioni del formato per gli stili e non è possibile rappresentare l’inserimento/eliminazione degli stili. Pertanto i documenti possono avere un diverso set di stili e il metodo Compare non produce ancora revisioni.

Il seguente esempio di codice mostra come verificare se due documenti sono uguali o meno:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document docA = new Document(dataDir + "TestFile.doc");
Document docB = new Document(dataDir + "TestFile - Copy.doc");
// DocA now contains changes as revisions. 
docA.Compare(docB, "user", DateTime.Now);
if (docA.Revisions.Count == 0)
    Console.WriteLine("Documents are equal");
else
    Console.WriteLine("Documents are not equal");

Il seguente esempio di codice mostra come applicare semplicemente il metodo Compare a due documenti:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// The source document doc1.
Document doc1 = new Document();
DocumentBuilder builder = new DocumentBuilder(doc1);
builder.Writeln("This is the original document.");

// The target document doc2.
Document doc2 = new Document();
builder = new DocumentBuilder(doc2);
builder.Writeln("This is the edited document.");

// If either document has a revision, an exception will be thrown.
if (doc1.Revisions.Count == 0 && doc2.Revisions.Count == 0)
    doc1.Compare(doc2, "authorName", DateTime.Now);

// If doc1 and doc2 are different, doc1 now has some revisions after the comparison, which can now be viewed and processed.
Assert.AreEqual(2, doc1.Revisions.Count);

foreach (Revision r in doc1.Revisions)
{
    Console.WriteLine($"Revision type: {r.RevisionType}, on a node of type \"{r.ParentNode.NodeType}\"");
    Console.WriteLine($"\tChanged text: \"{r.ParentNode.GetText()}\"");
}

// All the revisions in doc1 are differences between doc1 and doc2, so accepting them on doc1 transforms doc1 into doc2.
doc1.Revisions.AcceptAll();

// doc1, when saved, now resembles doc2.
doc1.Save(dataDir + "Document.Compare.docx");
doc1 = new Document(dataDir + "Document.Compare.docx");
Assert.AreEqual(0, doc1.Revisions.Count);
Assert.AreEqual(doc2.GetText().Trim(), doc1.GetText().Trim());

Specificare le opzioni di confronto avanzate

Esistono molte proprietà diverse della classe CompareOptions che puoi applicare quando desideri confrontare documenti.

Ad esempio, Aspose.Words consente di ignorare le modifiche apportate durante un’operazione di confronto per determinati tipi di oggetti all’interno del documento originale. È possibile selezionare la proprietà appropriata per il tipo di oggetto, ad esempio IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments e altre, impostandole su “true”.

Inoltre Aspose.Words mette a disposizione la proprietà Granularity con la quale è possibile specificare se tenere traccia delle modifiche per carattere o per parola.

Un’altra proprietà comune è la scelta del documento in cui mostrare i cambiamenti di confronto. Ad esempio, nella finestra di dialogo “Confronta documenti” in Microsoft Word è presente l’opzione “Mostra modifiche in” che influisce anche sui risultati del confronto. Aspose.Words fornisce la proprietà Target che serve a questo scopo.

L’esempio di codice seguente mostra come impostare le proprietà di confronto avanzate:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Create the original document.
Document docOriginal = new Document();
DocumentBuilder builder = new DocumentBuilder(docOriginal);

// Insert paragraph text with an endnote.
builder.Writeln("Hello world! This is the first paragraph.");
builder.InsertFootnote(FootnoteType.Endnote, "Original endnote text.");

// Insert a table.
builder.StartTable();
builder.InsertCell();
builder.Write("Original cell 1 text");
builder.InsertCell();
builder.Write("Original cell 2 text");
builder.EndTable();

// Insert a textbox.
Shape textBox = builder.InsertShape(ShapeType.TextBox, 150, 20);
builder.MoveTo(textBox.FirstParagraph);
builder.Write("Original textbox contents");

// Insert a DATE field.
builder.MoveTo(docOriginal.FirstSection.Body.AppendParagraph(""));
builder.InsertField(" DATE ");

// Insert a comment.
Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", DateTime.Now);
newComment.SetText("Original comment.");
builder.CurrentParagraph.AppendChild(newComment);

// Insert a header.
builder.MoveToHeaderFooter(HeaderFooterType.HeaderPrimary);
builder.Writeln("Original header contents.");

// Create a clone of our document, which we will edit and later compare to the original.
Document docEdited = (Document)docOriginal.Clone(true);
Paragraph firstParagraph = docEdited.FirstSection.Body.FirstParagraph;

// Change the formatting of the first paragraph, change casing of original characters and add text.
firstParagraph.Runs[0].Text = "hello world! this is the first paragraph, after editing.";
firstParagraph.ParagraphFormat.Style = docEdited.Styles[StyleIdentifier.Heading1];

// Edit the footnote.
Footnote footnote = (Footnote)docEdited.GetChild(NodeType.Footnote, 0, true);
footnote.FirstParagraph.Runs[1].Text = "Edited endnote text.";

// Edit the table.
Table table = (Table)docEdited.GetChild(NodeType.Table, 0, true);
table.FirstRow.Cells[1].FirstParagraph.Runs[0].Text = "Edited Cell 2 contents";

// Edit the textbox.
textBox = (Shape)docEdited.GetChild(NodeType.Shape, 0, true);
textBox.FirstParagraph.Runs[0].Text = "Edited textbox contents";

// Edit the DATE field.
FieldDate fieldDate = (FieldDate)docEdited.Range.Fields[0];
fieldDate.UseLunarCalendar = true;

// Edit the comment.
Comment comment = (Comment)docEdited.GetChild(NodeType.Comment, 0, true);
comment.FirstParagraph.Runs[0].Text = "Edited comment.";

// Edit the header.
docEdited.FirstSection.HeadersFooters[HeaderFooterType.HeaderPrimary].FirstParagraph.Runs[0].Text = "Edited header contents.";

// Apply different comparing options.
CompareOptions compareOptions = new CompareOptions();
compareOptions.IgnoreFormatting = false;
compareOptions.IgnoreCaseChanges = false;
compareOptions.IgnoreComments = false;
compareOptions.IgnoreTables = false;
compareOptions.IgnoreFields = false;
compareOptions.IgnoreFootnotes = false;
compareOptions.IgnoreTextboxes = false;
compareOptions.IgnoreHeadersAndFooters = false;
compareOptions.Target = ComparisonTargetType.New;

// compare both documents.
docOriginal.Compare(docEdited, "John Doe", DateTime.Now, compareOptions);
docOriginal.Save(dataDir + "Document.CompareOptions.docx");

docOriginal = new Document(dataDir + "Document.CompareOptions.docx");

// If you set compareOptions to ignore certain types of changes,
// then revisions done on those types of nodes will not appear in the output document.
// You can tell what kind of node a revision was done on by looking at the NodeType of the revision's parent nodes.
Assert.AreNotEqual(compareOptions.IgnoreFormatting, docOriginal.Revisions.Any(rev => rev.RevisionType == RevisionType.FormatChange));
Assert.AreNotEqual(compareOptions.IgnoreCaseChanges, docOriginal.Revisions.Any(s => s.ParentNode.GetText().Contains("hello")));
Assert.AreNotEqual(compareOptions.IgnoreComments, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Comment)));
Assert.AreNotEqual(compareOptions.IgnoreTables, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Table)));
Assert.AreNotEqual(compareOptions.IgnoreFields, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.FieldStart)));
Assert.AreNotEqual(compareOptions.IgnoreFootnotes, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Footnote)));
Assert.AreNotEqual(compareOptions.IgnoreTextboxes, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Shape)));
Assert.AreNotEqual(compareOptions.IgnoreHeadersAndFooters, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.HeaderFooter)));