Śledź zmiany w dokumencie
Funkcja śledzenia zmian, zwana także przeglądaniem, umożliwia śledzenie zmian w treści i formatowaniu wprowadzonych przez Ciebie lub innych użytkowników. Ta funkcja zmiany ścieżki w formacie Aspose.Words obsługuje zmiany ścieżki w formacie Microsoft Word. Dzięki tej funkcji możesz uzyskać dostęp do poszczególnych wersji dokumentu i zastosować do nich różne właściwości.
Po włączeniu funkcji śledzenia zmian wszystkie wstawione, usunięte i zmodyfikowane elementy dokumentu zostaną wizualnie wyróżnione z informacją o tym, kto, kiedy i co zostały zmienione. Obiekty niosące informację o tym, co zostało zmienione, nazywane są “zmianami śledzącymi”. Załóżmy na przykład, że chcesz przejrzeć dokument i wprowadzić ważne zmiany – może to oznaczać konieczność wprowadzenia poprawek. Może być również konieczne wstawienie komentarzy w celu omówienia niektórych zmian. Tutaj właśnie pojawia się śledzenie zmian w dokumentach.
W tym artykule wyjaśniono, jak zarządzać zmianami wprowadzonymi przez wielu recenzentów w tym samym dokumencie i je śledzić, a także właściwości śledzenia zmian.
Co to jest rewizja
Zanim zagłębimy się w wersje, wyjaśnijmy znaczenie wersji. revision to zmiana zachodząca w jednym węźle dokumentu, natomiast grupa wersji reprezentowana przez klasę RevisionGroup to grupa kolejnych wersji, które występują w wielu węzłach dokumentu. Zasadniczo wersja jest narzędziem do śledzenia zmian.
Wersje są wykorzystywane w funkcji śledzenia zmian oraz w funkcji porównywania dokumentów, gdzie poprawki pojawiają się w wyniku porównania. Zatem poprawki w ramach funkcji śledzenia zmian pokazują, kto i co zostało zmienione.
Aspose.Words obsługuje różne typy wersji, a także Microsoft Word, takie jak Wstawianie, Usuwanie, FormatChange, StyleDefinitionChange i Przenoszenie. Wszystkie typy wersji są reprezentowane za pomocą wyliczenia RevisionType.
Rozpocznij i zatrzymaj śledzenie zmian
Edytowanie dokumentu zwykle nie liczy się jako wersja, dopóki nie zaczniesz go śledzić. Aspose.Words umożliwia automatyczne śledzenie wszystkich zmian w dokumencie za pomocą prostych kroków. Proces śledzenia zmian możesz łatwo rozpocząć wykorzystując metodę StartTrackRevisions. Jeśli chcesz zatrzymać proces śledzenia zmian, aby przyszłe zmiany nie były traktowane jako poprawki, będziesz musiał użyć metody StopTrackRevisions.
StartTrackingRevisions
nie zmienia statusu właściwości TrackRevisions i nie wykorzystuje jej wartości w celu śledzenia wersji. Ponadto, jeśli węzeł został przeniesiony z jednej lokalizacji do drugiej w śledzonym dokumencie, zostaną utworzone wersje przeniesienia, obejmujące przesunięcie z i przesunięcie do zakresu.
Pod koniec procesu śledzenia zmian w dokumencie będziesz mieć możliwość zaakceptowania wszystkich poprawek lub odrzucenia ich, aby przywrócić dokument do pierwotnej formy. Można to osiągnąć za pomocą metody AcceptAllRevisions lub RejectAll. Ponadto możesz zaakceptować lub odrzucić każdą wersję z osobna, korzystając z metody Accept lub Reject.
Wszystkie zmiany będą śledzone przez jedną iterację od momentu rozpoczęcia procesu do momentu jego zatrzymania. Połączenie między różnymi iteracjami przedstawiono w następującym scenariuszu: kończysz proces śledzenia, następnie wprowadzasz pewne zmiany i ponownie rozpoczynasz śledzenie zmian. W tym scenariuszu wszystkie zmiany, których nie zaakceptowałeś lub odrzuciłeś, zostaną wyświetlone ponownie.
AcceptAllRevisions
jest podobna do metody “Zaakceptuj wszystkie zmiany” w formacie Microsoft Word.
Poniższy przykład kodu pokazuje, jak pracować ze śledzeniem zmian:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
Body body = doc.FirstSection.Body; | |
Paragraph para = body.FirstParagraph; | |
// Add text to the first paragraph, then add two more paragraphs. | |
para.AppendChild(new Run(doc, "Paragraph 1. ")); | |
body.AppendParagraph("Paragraph 2. "); | |
body.AppendParagraph("Paragraph 3. "); | |
// We have three paragraphs, none of which registered as any type of revision | |
// If we add/remove any content in the document while tracking revisions, | |
// they will be displayed as such in the document and can be accepted/rejected. | |
doc.StartTrackRevisions("John Doe", DateTime.Now); | |
// This paragraph is a revision and will have the according "IsInsertRevision" flag set. | |
para = body.AppendParagraph("Paragraph 4. "); | |
Assert.True(para.IsInsertRevision); | |
// Get the document's paragraph collection and remove a paragraph. | |
ParagraphCollection paragraphs = body.Paragraphs; | |
Assert.AreEqual(4, paragraphs.Count); | |
para = paragraphs[2]; | |
para.Remove(); | |
// Since we are tracking revisions, the paragraph still exists in the document, will have the "IsDeleteRevision" set | |
// and will be displayed as a revision in Microsoft Word, until we accept or reject all revisions. | |
Assert.AreEqual(4, paragraphs.Count); | |
Assert.True(para.IsDeleteRevision); | |
// The delete revision paragraph is removed once we accept changes. | |
doc.AcceptAllRevisions(); | |
Assert.AreEqual(3, paragraphs.Count); | |
Assert.That(para, Is.Empty); | |
// Stopping the tracking of revisions makes this text appear as normal text. | |
// Revisions are not counted when the document is changed. | |
doc.StopTrackRevisions(); | |
// Save the document. | |
doc.Save(ArtifactsDir + "WorkingWithRevisions.AcceptRevisions.docx"); |
Poniższy przykład kodu pokazuje, w jaki sposób generowane są poprawki, gdy węzeł jest przenoszony w śledzonym dokumencie:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
builder.Writeln("Paragraph 1"); | |
builder.Writeln("Paragraph 2"); | |
builder.Writeln("Paragraph 3"); | |
builder.Writeln("Paragraph 4"); | |
builder.Writeln("Paragraph 5"); | |
builder.Writeln("Paragraph 6"); | |
Body body = doc.FirstSection.Body; | |
Console.WriteLine("Paragraph count: {0}", body.Paragraphs.Count); | |
// Start tracking revisions. | |
doc.StartTrackRevisions("Author", new DateTime(2020, 12, 23, 14, 0, 0)); | |
// Generate revisions when moving a node from one location to another. | |
Node node = body.Paragraphs[3]; | |
Node endNode = body.Paragraphs[5].NextSibling; | |
Node referenceNode = body.Paragraphs[0]; | |
while (node != endNode) | |
{ | |
Node nextNode = node.NextSibling; | |
body.InsertBefore(node, referenceNode); | |
node = nextNode; | |
} | |
// Stop the process of tracking revisions. | |
doc.StopTrackRevisions(); | |
// There are 3 additional paragraphs in the move-from range. | |
Console.WriteLine("Paragraph count: {0}", body.Paragraphs.Count); | |
doc.Save(ArtifactsDir + "WorkingWithRevisions.MoveNodeInTrackedDocument.docx"); |
Zarządzaj zmianami i przechowuj je jako wersje
Dzięki poprzedniej funkcji śledzenia zmian możesz dowiedzieć się, jakie zmiany zostały wprowadzone w dokumencie i kto je wprowadził. Korzystając z funkcji TrackRevisions, wymuszasz zapisanie wszelkich zmian w dokumencie jako wersji.
Aspose.Words pozwala sprawdzić, czy dokument ma wersję, czy nie, za pomocą właściwości HasRevision. Jeśli nie musisz automatycznie śledzić zmian w dokumencie za pomocą metod StartTrackRevisions i StopTrackRevisions, możesz użyć właściwości TrackRevisions
, aby sprawdzić, czy zmiany są śledzone podczas edycji dokumentu w Microsoft Word i przechowywane jako wersje.
Funkcja TrackRevisions
wprowadza poprawki zamiast rzeczywistych zmian DOM. Ale same poprawki są odrębne. Na przykład, jeśli usuniesz dowolny akapit, plik Aspose.Words uczyni go poprawką, zaznaczając go jako usunięty, zamiast go usuwać.
Ponadto Aspose.Words umożliwia sprawdzenie, czy obiekt został wstawiony, usunięty lub zmienione formatowanie przy użyciu właściwości IsDeleteRevision, IsFormatRevision, IsInsertRevision, IsMoveFromRevision i IsMoveToRevision.
TrackRevisions
. Ponadto możesz akceptować/odrzucać poprawki niezależnie od funkcji śledzenia zmian.
Poniższy przykład kodu pokazuje, jak zastosować różne właściwości w wersjach:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
// Insert an inline shape without tracking revisions. | |
Assert.False(doc.TrackRevisions); | |
Shape shape = new Shape(doc, ShapeType.Cube); | |
shape.WrapType = WrapType.Inline; | |
shape.Width = 100.0; | |
shape.Height = 100.0; | |
doc.FirstSection.Body.FirstParagraph.AppendChild(shape); | |
// Start tracking revisions and then insert another shape. | |
doc.StartTrackRevisions("John Doe"); | |
shape = new Shape(doc, ShapeType.Sun); | |
shape.WrapType = WrapType.Inline; | |
shape.Width = 100.0; | |
shape.Height = 100.0; | |
doc.FirstSection.Body.FirstParagraph.AppendChild(shape); | |
// Get the document's shape collection which includes just the two shapes we added. | |
List<Shape> shapes = doc.GetChildNodes(NodeType.Shape, true).Cast<Shape>().ToList(); | |
Assert.AreEqual(2, shapes.Count); | |
// Remove the first shape. | |
shapes[0].Remove(); | |
// Because we removed that shape while changes were being tracked, the shape counts as a delete revision. | |
Assert.AreEqual(ShapeType.Cube, shapes[0].ShapeType); | |
Assert.True(shapes[0].IsDeleteRevision); | |
// And we inserted another shape while tracking changes, so that shape will count as an insert revision. | |
Assert.AreEqual(ShapeType.Sun, shapes[1].ShapeType); | |
Assert.True(shapes[1].IsInsertRevision); | |
// The document has one shape that was moved, but shape move revisions will have two instances of that shape. | |
// One will be the shape at its arrival destination and the other will be the shape at its original location. | |
doc = new Document(MyDir + "Revision shape.docx"); | |
shapes = doc.GetChildNodes(NodeType.Shape, true).Cast<Shape>().ToList(); | |
Assert.AreEqual(2, shapes.Count); | |
// This is the move to revision, also the shape at its arrival destination. | |
Assert.False(shapes[0].IsMoveFromRevision); | |
Assert.True(shapes[0].IsMoveToRevision); | |
// This is the move from revision, which is the shape at its original location. | |
Assert.True(shapes[1].IsMoveFromRevision); | |
Assert.False(shapes[1].IsMoveToRevision); |