Dokumente vergleichen

Der Vergleich von Dokumenten ist ein Prozess, der Änderungen zwischen zwei Dokumenten identifiziert und die Änderungen als Revisionen enthält. Bei diesem Vorgang werden zwei beliebige Dokumente verglichen, einschließlich Versionen eines bestimmten Dokuments. Anschließend werden die Änderungen zwischen beiden Dokumenten als Überarbeitungen im ersten Dokument angezeigt.

Die Vergleichsmethode wird durch den Vergleich von Wörtern auf Zeichenebene oder auf Wortebene erreicht. Wenn ein Wort eine Änderung von mindestens einem Zeichen enthält, wird der Unterschied im Ergebnis als Änderung des gesamten Worts und nicht eines Zeichens angezeigt. Dieser Vergleichsprozess ist eine übliche Aufgabe in der Rechts- und Finanzbranche.

Anstatt manuell nach Unterschieden zwischen Dokumenten oder zwischen verschiedenen Versionen davon zu suchen, können Sie Aspose.Words zum Vergleichen von Dokumenten und zum Abrufen von Inhaltsänderungen in Formatierung, Kopf-/Fußzeile, Tabellen und mehr verwenden.

In diesem Artikel wird erläutert, wie Sie Dokumente vergleichen und die erweiterten Vergleichseigenschaften festlegen.

Versuchen Sie es online

Mit dem Dokumentenvergleich online-Tool können Sie zwei Dokumente online vergleichen.

Beachten Sie, dass in diesem Tool die unten beschriebene Vergleichsmethode verwendet wird, um sicherzustellen, dass gleiche Ergebnisse erzielt werden. Sie erhalten also die gleichen Ergebnisse, auch wenn Sie das Online Vergleichstool oder die Vergleichsmethode in Aspose.Words verwenden.

Einschränkungen und unterstützte Dateiformate

Der Vergleich von Dokumenten ist eine sehr komplexe Funktion. Es gibt verschiedene Teile der Inhaltskombination, die analysiert werden müssen, um alle Unterschiede zu erkennen. Der Grund für diese Komplexität liegt darin, dass Aspose.Words darauf abzielt, die gleichen Vergleichsergebnisse wie der Microsoft Word-Vergleichsalgorithmus zu erzielen.

Die allgemeine Einschränkung für zwei zu vergleichende Dokumente besteht darin, dass sie vor dem Aufruf der Vergleichsmethode keine Revisionen aufweisen dürfen, da diese Einschränkung in Microsoft Word besteht.

Beachten Sie, dass Sie zwei beliebige Dokumente innerhalb des Unterstützte Dokumentformate vergleichen können. Grundsätzlich können Sie Dokumentobjekte vergleichen und diese Objekte sogar von Grund auf erstellen, ohne ein bestimmtes Format zu haben.

Vergleichen Sie zwei Dokumente

Wenn Sie Dokumente vergleichen, werden Unterschiede zwischen dem letztgenannten und dem erstgenannten Dokument als Überarbeitungen des erstgenannten Dokuments angezeigt. Wenn Sie ein Dokument ändern, erhält jede Änderung nach Ausführung der Vergleichsmethode eine eigene Revision.

Mit Aspose.Words können Sie Dokumentunterschiede mithilfe der Compare-Methode identifizieren – diese ähnelt der Funktion zum Vergleichen von Microsoft Word-Dokumenten. Es ermöglicht Ihnen, Dokumente oder Dokumentversionen zu überprüfen, um Unterschiede und Änderungen zu finden, einschließlich Formatierungsänderungen wie Schriftartänderungen, Abstandsänderungen, das Hinzufügen von Wörtern und Absätzen.

Durch den Vergleich kann festgestellt werden, ob Dokumente gleich oder ungleich sind. Der Begriff “gleiche” Dokumente bedeutet, dass die Vergleichsmethode Änderungen nicht als Revisionen darstellen kann. Das bedeutet, dass sowohl der Dokumenttext als auch die Textformatierung gleich sind. Es kann aber auch andere Unterschiede zwischen Dokumenten geben. Microsoft Word unterstützt beispielsweise nur Formatrevisionen für Stile und Sie können das Einfügen/Löschen von Stilen nicht darstellen. Dokumente können also unterschiedliche Stile haben und die Compare-Methode erzeugt dennoch keine Revisionen.

Das folgende Codebeispiel zeigt, wie man prüft, ob zwei Dokumente gleich sind oder nicht:

// 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");

Das folgende Codebeispiel zeigt, wie Sie die Compare-Methode einfach auf zwei Dokumente anwenden:

// 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());

Geben Sie die erweiterten Vergleichsoptionen {#specify-advanced-comparing-properties} an

Es gibt viele verschiedene Eigenschaften der CompareOptions-Klasse, die Sie beim Vergleichen von Dokumenten anwenden können.

Mit Aspose.Words können Sie beispielsweise Änderungen ignorieren, die während eines Vergleichsvorgangs für bestimmte Objekttypen im Originaldokument vorgenommen wurden. Sie können die entsprechende Eigenschaft für den Objekttyp auswählen, z. B. IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments und andere, indem Sie sie auf “true” festlegen.

Darüber hinaus bietet Aspose.Words die Granularity-Eigenschaft, mit der Sie angeben können, ob Änderungen zeichen- oder wortweise verfolgt werden sollen.

Eine weitere gemeinsame Eigenschaft ist die Auswahl, in welchem Dokument Vergleichsänderungen angezeigt werden sollen. Beispielsweise verfügt das “Dialogfeld “Dokumente vergleichen”” in Microsoft Word über die Option “Änderungen anzeigen in” – dies wirkt sich auch auf die Vergleichsergebnisse aus. Aspose.Words stellt die Target-Eigenschaft bereit, die diesem Zweck dient.

Das folgende Codebeispiel zeigt, wie die erweiterten Vergleichseigenschaften festgelegt werden:

// 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)));