Vergelyk Dokumente

Die vergelyking van dokumente is’n proses wat veranderinge tussen twee dokumente identifiseer en die veranderinge as hersienings bevat. Hierdie proses vergelyk enige twee dokumente, insluitend weergawes van een spesifieke dokument, dan sal die veranderinge tussen beide dokumente as hersienings in die eerste dokument vertoon word.

Die vergelykingsmetode word bereik deur woorde op karaktervlak of op woordvlak te vergelyk. As’n woord’n verandering van ten minste een karakter bevat, sal die verskil in die resultaat vertoon word as’n verandering van die hele woord, nie’n karakter nie. Hierdie vergelykingsproses is’n gewone taak in die regs-en finansiële bedrywe.

In plaas daarvan om handmatig na verskille tussen dokumente of tussen verskillende weergawes daarvan te soek, kan jy Aspose.Words gebruik om dokumente te vergelyk en inhoudveranderings in formatering, koptekst/voetskrif, tabelle en meer te kry.

Hierdie artikel verduidelik hoe om dokumente te vergelyk en hoe om die gevorderde vergelykende eienskappe te spesifiseer.

Beperkings en Ondersteunde Lêerformate

Vergelyking van dokumente is’n baie komplekse kenmerk. Daar is verskillende dele van inhoudkombinasie wat ontleed moet word om alle verskille te herken. Die rede vir hierdie kompleksiteit is te wyte aan die feit dat Aspose.Words dieselfde vergelykingsresultate as die Microsoft Word vergelykingsalgoritme wil kry.

Die algemene beperking vir twee dokumente wat vergelyk word, is dat hulle nie hersienings mag hê voordat hulle die vergelykingsmetode noem nie, aangesien hierdie beperking in Microsoft Word bestaan.

Vergelyk Twee Dokumente

Wanneer jy dokumente vergelyk, verskyn verskille van laasgenoemde dokument van eersgenoemde as hersienings van eersgenoemde. As u’n dokument verander, sal elke wysiging sy eie hersiening hê nadat u die vergelykingsmetode uitgevoer het.

Aspose.Words laat jou toe om dokumente verskille te identifiseer met behulp van die Compare metode – dit is soortgelyk aan die Microsoft Word dokument vergelyk funksie. Dit laat jou toe om dokumente of dokumentweergawes na te gaan om verskille en veranderinge te vind, insluitend formateringsaanpassings soos lettertipeveranderings, spasiëringsveranderinge, die byvoeging van woorde en paragrawe.

As gevolg van vergelyking kan dokumente as gelyk of nie gelyk bepaal word nie. Die term “gelyke” dokumente beteken dat die vergelykingsmetode nie veranderinge as hersienings kan voorstel nie. Dit beteken dat beide dokument teks en teks formatering is dieselfde. Maar daar kan ander verskille tussen dokumente wees. Byvoorbeeld, Microsoft Word ondersteun slegs formaat hersienings vir style, en jy kan nie styl invoeging/verwydering verteenwoordig. Dokumente kan dus’n ander stel style hê, en die Compare metode lewer steeds geen hersienings nie.

Die volgende kode voorbeeld toon hoe om te kyk of twee dokumente is gelyk of nie:

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

Die volgende kode voorbeeld toon hoe om eenvoudig die Compare metode toe te pas op twee dokumente:

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

Spesifiseer Gevorderde Vergelykingsopsies

Daar is baie verskillende eienskappe van die CompareOptions klas wat jy kan aansoek doen wanneer jy wil dokumente te vergelyk.

Byvoorbeeld, Aspose.Words laat jou toe om veranderinge wat tydens’n vergelykingsbewerking vir sekere soorte voorwerpe in die oorspronklike dokument gemaak is, te ignoreer. Jy kan die toepaslike eienskap vir die voorwerp tipe kies, soos IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, en ander deur hulle op “waar"te stel.

Daarbenewens bied Aspose.Words die Granularity eienskap waarmee u kan spesifiseer of u veranderinge volgens karakter of woord moet opspoor.

Nog’n gemeenskaplike eienskap is’n keuse in watter dokument om vergelyking veranderinge te wys. Byvoorbeeld, die” Vergelyk dokumente dialoog boks “in Microsoft Word het die opsie” Wys veranderinge in " – dit beïnvloed ook die vergelyking resultate. Aspose.Words verskaf die Target eienskap wat hierdie doel dien.

Die volgende kode voorbeeld toon hoe om die gevorderde vergelyking eienskappe stel:

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