Comparați documentele

Comparați documentele este un proces care identifică modificările dintre două documente și conține modificările ca revizii. Acest proces compară orice două documente, inclusiv versiunile unuia singur document, apoi modificările dintre ambele documente vor fi arătate ca reviziuni în primul document.

Metoda de comparație se obține prin compararea cuvintelor la nivel de caractere sau la nivel de cuvinte. Dacă un cuvânt conține o schimbare de cel puțin un caracter, în rezultatul final diferența va fi afișată ca o schimbare a întregului cuvânt, nu a unui caracter. Acest proces de comparație este o sarcină obișnuită în industriile juridice și financiare.

În loc să cauți manual diferențele între documente sau între diferite versiuni ale acestora, poți folosi Aspose.Words pentru compararea documentelor și obținerea modificărilor de conținut în formatare, antet/subantet, tabele și altele.

Acest articol explică cum să comparăm documente și cum să specificăm proprietățile de comparare avansată.

Limitari şi formate de fişiere acceptate

Compararea documentelor este o caracteristică foarte complexă. Există părți variate ale combinației de conținut care trebuie analizate pentru a recunoaște toate diferențele. Motivul acestei complexități este din faptul că Aspose.Words își propune să obțină aceleași rezultate de comparație ca algoritmul de comparație Microsoft Word.

Limita generală pentru două documente care sunt comparate este că nu trebuie să aibă revizuiri înainte de a apela metoda comparați ca această limită există în Microsoft Word.

Comparaţi două documente

Când compari documentele, diferențele din cel de-al doilea document față de primul se arată ca niște modificări ale celui de-al doilea față de primul. Când modifici un document, fiecare modificare va avea propria sa revizuire după ce rulezi metoda de comparare.

Aspose.Words vă permite să identificați diferențele de documente utilizând metoda Compare – aceasta este similară cu caracteristica de comparare a documentelor Microsoft Word. Îți permite să verifici documente sau versiuni de documente pentru a găsi diferențe și modificări, inclusiv modificări ale formatării, cum ar fi schimbarea fontului, modificări de spațiu, adăugarea de cuvinte și paragrafe.

Ca rezultat al comparației, documentele pot fi determinate ca fiind egale sau nu egale. Termenul “documente egale” înseamnă că metoda de comparație nu este capabilă să reprezinte modificările ca revizuiri. Aceasta înseamnă că atât textul de document, cât și formatarea textului sunt aceleași. Dar pot exista și alte diferențe între documente. De exemplu Microsoft Word suportă doar revizuiri de format pentru stiluri și nu puteți reprezenta inserarea/ștergerea stilului. Astfel de documente pot avea un set diferit de stiluri, iar metoda Compare încă produce nicio revizuire.

Exemplul de cod următor arată cum se verifică dacă două documente sunt egale sau nu:

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

Exemplul de cod următor arată cum se poate aplica metoda Compare pur și simplu la două documente:

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

Specificați opțiunile de comparație avansate

Există multe proprietăți diferite ale clasei CompareOptions pe care le poți aplica când vrei să compari documente.

De exemplu Aspose.Words îți permite să ignori modificări făcute în timpul unei operații de comparare pentru anumite tipuri de obiecte din documentul original. Puteţi alege proprietatea corespunzătoare pentru tipul de obiect, cum ar fi IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments și altele prin setarea lor la “true”.

În plus, Aspose.Words oferă proprietatea Granularity, cu care puteți specifica dacă să urmăriți modificările prin caracter sau prin cuvânt.

O altă proprietate comună este o alegere în care document să afișeze modificările de comparație. Spre exemplu, caseta de dialog “Comparați documente” din Microsoft Word are opțiunea “Afișați modificările în”-acesta afectează și rezultatele comparației. Aspose.Words oferă proprietatea Target care servește acestui scop.

Exemplul de cod următor arată cum se setează proprietățile avansate de comparare:

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