Zachowaj metadane docelowe przy użyciu GroupDocs.Comparison – Samouczek .NET

Wprowadzenie

Czy kiedykolwiek porównywałeś dwa dokumenty i przy tym traciłeś ważne metadane? Nie jesteś sam. Kiedy w aplikacji .NET musisz zachować metadane docelowe podczas porównywania dokumentów, zadanie może wydawać się trudne — ale nie musi tak być.

GroupDocs.Comparison dla .NET pozwala określić, które metadane dokumentu mają przetrwać w wyniku porównania. Niezależnie od tego, czy budujesz system zarządzania dokumentami, obsługujesz umowy prawne, czy zarządzasz treściami współtworzonymi, zawsze będziesz chciał mieć metadane z właściwego źródła dokumentu.

W tym samouczku dowiesz się, jak zachować metadane docelowe podczas porównywania, jak unikać typowych pułapek i jak wdrożyć rozwiązanie w rzeczywistych scenariuszach.

Szybkie odpowiedzi

Co oznacza „zachować metadane docelowe”? Oznacza to, że metadane (autor, data utworzenia, własne właściwości itp.) z dokumentu wybranego jako docelowy zostają zachowane przy generowaniu wyniku porównania.
Która wersja GroupDocs.Comparison jest wymagana? Wersja 25.4.0 lub nowsza.
Czy mogę używać tego z .NET Core? Tak — .NET Core 2.0+ lub .NET Framework 4.6.1+.
Czy potrzebna jest licencja do produkcji? Do użytku produkcyjnego wymagana jest licencja komercyjna; wersja próbna wystarczy do nauki.
Czy funkcja działa z PDF i DOCX? Tak — wszystkie popularne formaty Office i PDF obsługują zachowywanie metadanych.

Dlaczego zachowywanie metadanych ma znaczenie

Zanim przejdziemy do kodu, omówmy, dlaczego zachowywanie metadanych docelowych jest ważne. Metadane dokumentu to nie tylko „miły dodatek” — często są wymagane prawnie lub są kluczowe dla biznesu:

Dokumenty prawne – muszą zachować znaczniki poufności adwokat‑klient.
Pliki korporacyjne – muszą zachować znaczniki zgodności i łańcuchy zatwierdzeń.
Prace naukowe – autorstwo i historia wersji są niezbędne.
Dokumentacja techniczna – kontrola wersji i status recenzji mają znaczenie.

Bez odpowiedniego traktowania możesz przypadkowo usunąć informacje, nad którymi pracowano miesiącami. Właśnie tutaj wkracza opcja zachowywania metadanych docelowych.

Wymagania wstępne

Wymagane biblioteki i wersje

GroupDocs.Comparison for .NET: wersja 25.4.0 lub nowsza (wcześniejsze wersje mają ograniczone opcje metadanych).
.NET Framework: 4.6.1 lub wyższy, lub .NET Core 2.0+.

Konfiguracja środowiska

Visual Studio (lub dowolne IDE C#, którego używasz).
Podstawowa znajomość C# (nic skomplikowanego, obiecuję!).
Dwa przykładowe dokumenty do testów (format Word .docx sprawdzi się doskonale).

Wymagania wiedzy

Nie musisz być ekspertem GroupDocs, ale powinieneś czuć się komfortowo z:

instrukcjami using w C# i obsługą plików,
podstawowymi pojęciami przetwarzania dokumentów,
tym, czym są metadane (autor, tytuł, własne właściwości itp.).

Gotowy? Zaczynamy.

Konfiguracja GroupDocs.Comparison dla .NET

Instalacja GroupDocs.Comparison jest prosta, ale warto zwrócić uwagę na kilka pułapek.

Opcje instalacji

NuGet Package Manager Console (najprostsza metoda):

Install-Package GroupDocs.Comparison -Version 25.4.0

.NET CLI (jeśli wolisz wiersz poleceń):

dotnet add package GroupDocs.Comparison --version 25.4.0

Wskazówka: Zawsze podawaj wersję, aby uniknąć nieoczekiwanych zmian łamiących projekt.

Uzyskanie licencji

Tutaj wielu programistów napotyka pierwsze trudności. GroupDocs.Comparison nie jest darmowy, ale masz kilka opcji:

Bezpłatna wersja próbna – pełna funkcjonalność przez 30 dni, idealna do oceny.
Licencja tymczasowa – wydłużony okres testowy, jeśli potrzebujesz więcej czasu.
Licencja komercyjna – do użytku produkcyjnego (różne poziomy cenowe).

Nie martw się o licencję, jeśli dopiero się uczysz — wersja próbna zawiera wszystkie funkcje zachowywania metadanych docelowych.

Podstawowa weryfikacja konfiguracji

Sprawdźmy, czy wszystko działa, uruchamiając prosty test:

using System.IO;
using GroupDocs.Comparison;

string sourceFilePath = "source.docx";
string targetFilePath = "target.docx";

// Initialize the Comparer object.
using (Comparer comparer = new Comparer(sourceFilePath))
{
    // Add the target document for comparison.
    comparer.Add(targetFilePath);
}

Jeśli kod skompiluje się bez błędów, możesz śmiało kontynuować. W przeciwnym razie sprawdź instalację pakietu i deklaracje using.

Jak zachować metadane docelowe

Teraz najważniejsza część — faktyczne zachowanie metadanych podczas porównywania dokumentów. To właśnie tutaj GroupDocs.Comparison błyszczy.

Zrozumienie przepływu metadanych

Podczas typowego porównania:

Dokument źródłowy dostarcza bazową treść.
Dokument docelowy dostarcza zmiany, które mają być porównane.
Dokument wynikowy łączy oba, ale które metadane przeważają?

Domyślnie GroupDocs.Comparison używa metadanych dokumentu źródłowego. Aby zachować metadane docelowe, musisz wyraźnie poinstruować API.

Implementacja krok po kroku

Krok 1: Zainicjuj obiekt Comparer

Ustalasz „bazowy” dokument — ten, z którym porównujesz:

using (Comparer comparer = new Comparer(sourceFilePath))
{
    // All comparison operations happen within this scope
}

Dlaczego używać instrukcji using? Automatycznie zwalniają zasoby, zapobiegając wyciekom pamięci przy przetwarzaniu dużych dokumentów. Uwierz mi, podziękujesz sobie później, gdy będziesz pracować z plikami Word o rozmiarze 50 MB.

Krok 2: Dodaj dokument docelowy

Powiedz comparerowi, który dokument zawiera zmiany do analizy:

comparer.Add(targetFilePath);

Typowy błąd: pomylenie źródła i celu. Pomyśl o tym tak — źródło to twoja „oryginał”, a cel to „zaktualizowana wersja”.

Krok 3: Ustaw typ metadanych (tu dzieje się magia)

Określ, które metadane mają zostać zachowane w wyniku:

comparer.Compare(outputFileName, new SaveOptions() { CloneMetadataType = MetadataType.Target });

Co się dzieje? CloneMetadataType = MetadataType.Target mówi GroupDocs.Comparison: „Hej, chcę zachować metadane dokumentu docelowego w finalnym wyniku”.

Kompletny działający przykład

Oto wszystko razem w programie gotowym do uruchomienia:

using System;
using System.IO;
using GroupDocs.Comparison;
using GroupDocs.Comparison.Options;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            string sourceFile = "original_document.docx";
            string targetFile = "updated_document.docx";
            string outputFile = "comparison_result.docx";
            
            using (Comparer comparer = new Comparer(sourceFile))
            {
                comparer.Add(targetFile);
                
                // Preserve target document metadata
                comparer.Compare(outputFile, new SaveOptions() 
                { 
                    CloneMetadataType = MetadataType.Target 
                });
                
                Console.WriteLine($"Comparison completed! Check {outputFile}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error during comparison: {ex.Message}");
        }
    }
}

Typowe pułapki do uniknięcia

Problemy ze ścieżkami — zawsze używaj pełnych ścieżek lub upewnij się, że pliki znajdują się w katalogu roboczym:

// Good
string sourceFile = Path.Combine(Directory.GetCurrentDirectory(), "docs", "source.docx");

// Risky (might work locally but fail in production)
string sourceFile = "source.docx";

Zarządzanie pamięcią — przy dużych dokumentach zawsze otaczaj obiekty Comparer instrukcją using.

Kompatybilność wersji — różne wydania GroupDocs.Comparison udostępniają różne opcje metadanych — trzymaj się 25.4.0 lub nowszej, aby uzyskać najlepsze rezultaty.

Zaawansowane scenariusze metadanych

Kiedy używać metadanych docelowych, a kiedy źródłowych

Scenariusz	Preferuj metadane docelowe	Preferuj metadane źródłowe
Potrzeba aktualnych danych autora	✅	❌
Dokument źródłowy ma pierwszeństwo prawne	❌	✅
Własne właściwości dodane tylko w nowszym pliku	✅	❌
Chcesz zachować historię „głównego” dokumentu	❌	✅

Obsługa wielu dokumentów docelowych

Możesz porównywać z kilkoma celami, zachowując metadane z pierwszego dodanego dokumentu docelowego:

using (Comparer comparer = new Comparer(sourceFilePath))
{
    comparer.Add(targetFilePath1);
    comparer.Add(targetFilePath2);
    comparer.Add(targetFilePath3);
    
    // Metadata will come from the first target document
    comparer.Compare(outputFileName, new SaveOptions() 
    { 
        CloneMetadataType = MetadataType.Target 
    });
}

Praktyczne zastosowania i przypadki użycia

Zarządzanie dokumentami prawnymi

Kancelarie często muszą porównywać wersje umów, zachowując określone znaczniki metadanych:

// Preserve client metadata from updated contract
using (Comparer comparer = new Comparer("original_contract.docx"))
{
    comparer.Add("client_revised_contract.docx");
    
    comparer.Compare("final_contract_comparison.docx", new SaveOptions() 
    { 
        CloneMetadataType = MetadataType.Target  // Keep client's metadata
    });
}

Współpraca akademicka i badawcza

Gdy wielu badaczy współpracuje, chcesz zachować najnowsze informacje o autorze:

// Keep metadata from the researcher's latest submission
using (Comparer comparer = new Comparer("draft_paper.docx"))
{
    comparer.Add("researcher_updates.docx");
    
    comparer.Compare("paper_comparison.docx", new SaveOptions() 
    { 
        CloneMetadataType = MetadataType.Target  // Preserve researcher metadata
    });
}

Przepływy pracy w zgodności korporacyjnej

W branżach regulowanych utrzymanie metadanych zgodności jest krytyczne:

// Preserve compliance tags from updated policy document
using (Comparer comparer = new Comparer("old_policy.docx"))
{
    comparer.Add("compliance_approved_policy.docx");
    
    comparer.Compare("policy_comparison.docx", new SaveOptions() 
    { 
        CloneMetadataType = MetadataType.Target  // Keep compliance metadata
    });
}

Rozwiązywanie typowych problemów

Błędy „File Not Found”

Najczęstszy problem. Debuguj, dodając wyraźne kontrole:

string sourceFile = "source.docx";

// Always check if files exist before comparison
if (!File.Exists(sourceFile))
{
    Console.WriteLine($"Source file not found: {Path.GetFullPath(sourceFile)}");
    return;
}

// Same for target files
if (!File.Exists(targetFile))
{
    Console.WriteLine($"Target file not found: {Path.GetFullPath(targetFile)}");
    return;
}

Problemy z pamięcią przy dużych dokumentach

Dla dokumentów powyżej 10 MB rozważ następujące optymalizacje:

// Use explicit disposal for large documents
using (var comparer = new Comparer(sourceFile))
{
    comparer.Add(targetFile);
    
    var saveOptions = new SaveOptions() 
    { 
        CloneMetadataType = MetadataType.Target 
    };
    
    comparer.Compare(outputFile, saveOptions);
    
    // Explicitly clean up
    GC.Collect();
    GC.WaitForPendingFinalizers();
}

Problemy z uprawnieniami i dostępem

Podczas pracy z chronionymi plikami lub udziałami sieciowymi:

try
{
    using (var comparer = new Comparer(sourceFile))
    {
        comparer.Add(targetFile);
        comparer.Compare(outputFile, new SaveOptions() 
        { 
            CloneMetadataType = MetadataType.Target 
        });
    }
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Access denied. Check file permissions.");
    Console.WriteLine($"Details: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine("File I/O error occurred.");
    Console.WriteLine($"Details: {ex.Message}");
}

Wydajność i dobre praktyki

Zarządzanie pamięcią

GroupDocs.Comparison może intensywnie wykorzystywać pamięć. Używaj instrukcji using, aby zagwarantować zwolnienie zasobów:

// Good - automatic resource cleanup
using (var comparer = new Comparer(sourceFile))
{
    // comparison logic here
}

// Bad - potential memory leaks
var comparer = new Comparer(sourceFile);
// ... comparison logic
// comparer.Dispose(); // Easy to forget!

Przetwarzaj dokumenty w partiach — jeśli porównujesz wiele plików, obsługuj je w mniejszych grupach, aby utrzymać niskie zużycie pamięci.

Operacje asynchroniczne dla lepszej responsywności

W aplikacjach desktopowych lub webowych opakuj porównanie w metodę async:

public async Task<bool> CompareDocumentsAsync(string source, string target, string output)
{
    return await Task.Run(() =>
    {
        try
        {
            using (var comparer = new Comparer(source))
            {
                comparer.Add(target);
                comparer.Compare(output, new SaveOptions() 
                { 
                    CloneMetadataType = MetadataType.Target 
                });
                return true;
            }
        }
        catch
        {
            return false;
        }
    });
}

Wytyczne dotyczące rozmiaru plików

Małe (< 1 MB) – przetwarzaj bezpośrednio.
Średnie (1‑10 MB) – wyświetlaj postęp, aby UI pozostało responsywne.
Duże (> 10 MB) – zawsze używaj przetwarzania asynchronicznego i rozważ ręczne wywołanie GC, jak pokazano wyżej.

Integracja z większymi systemami

Integracja z ASP.NET Core

Poniżej gotowy kontroler, który przyjmuje dwa pliki, wykonuje porównanie i zwraca wynik, jednocześnie zachowując metadane docelowe:

[ApiController]
[Route("api/[controller]")]
public class DocumentComparisonController : ControllerBase
{
    [HttpPost("compare-with-target-metadata")]
    public async Task<IActionResult> CompareWithTargetMetadata(
        IFormFile sourceFile, 
        IFormFile targetFile)
    {
        var tempSource = Path.GetTempFileName();
        var tempTarget = Path.GetTempFileName();
        var outputPath = Path.GetTempFileName();
        
        try
        {
            // Save uploaded files temporarily
            await sourceFile.CopyToAsync(new FileStream(tempSource, FileMode.Create));
            await targetFile.CopyToAsync(new FileStream(tempTarget, FileMode.Create));
            
            // Perform comparison with target metadata preservation
            using (var comparer = new Comparer(tempSource))
            {
                comparer.Add(tempTarget);
                comparer.Compare(outputPath, new SaveOptions() 
                { 
                    CloneMetadataType = MetadataType.Target 
                });
            }
            
            // Return comparison result
            var resultBytes = await System.IO.File.ReadAllBytesAsync(outputPath);
            return File(resultBytes, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", 
                       "comparison_result.docx");
        }
        finally
        {
            // Clean up temporary files
            if (System.IO.File.Exists(tempSource)) System.IO.File.Delete(tempSource);
            if (System.IO.File.Exists(tempTarget)) System.IO.File.Delete(tempTarget);
            if (System.IO.File.Exists(outputPath)) System.IO.File.Delete(outputPath);
        }
    }
}

Najczęściej zadawane pytania

P: Czy mogę zachować metadane z wielu dokumentów docelowych przy porównywaniu?
O: Gdy dodasz kilka plików docelowych, GroupDocs.Comparison używa metadanych z pierwszego dodanego dokumentu docelowego. Dodaj więc najpierw ten, którego metadane chcesz zachować.

P: Co się stanie, jeśli dokument docelowy nie zawiera niektórych pól metadanych?
O: Skopiowane zostaną tylko istniejące w dokumencie docelowym metadane. Brakujące pola zostaną pominięte; porównanie zakończy się sukcesem.

P: Jak obsłużyć dokumenty zabezpieczone hasłem?
O: Użyj obiektu LoadOptions z hasłem, a następnie przekaż go do konstruktora Comparer:

var loadOptions = new LoadOptions() { Password = "your_password" };
using (var comparer = new Comparer(sourceFile, loadOptions))
{
    // comparison logic here
}

P: Czy istnieje sposób, aby zachować tylko wybrane właściwości metadanych?
O: Obecne API zachowuje wszystkie metadane z wybranego źródła (Target lub Source). Aby uzyskać kontrolę na poziomie poszczególnych właściwości, trzeba po porównaniu wyodrębnić właściwości i zastosować je ręcznie.

P: Które formaty dokumentów obsługują zachowywanie metadanych?
O: Większość popularnych formatów biznesowych — DOCX, PDF, PPTX, XLSX i wiele innych — obsługuje zachowywanie metadanych. Pełną listę znajdziesz w oficjalnej dokumentacji.

P: Gdzie mogę uzyskać pomoc, jeśli napotkam problemy?
O: Odwiedź Forum wsparcia GroupDocs dla pomocy społeczności lub skontaktuj się bezpośrednio z zespołem wsparcia GroupDocs, jeśli posiadasz licencję komercyjną.

Dodatkowe zasoby

Oficjalna dokumentacja: GroupDocs.Comparison for .NET Docs
Referencja API: Complete API Reference
Pobierz najnowszą wersję: GroupDocs Downloads
Bezpłatna wersja próbna: Start Your Trial
Opcje zakupu: Licencjonowanie i ceny

Ostatnia aktualizacja: 2026-03-06
Testowano z: GroupDocs.Comparison 25.4.0 for .NET
Autor: GroupDocs

FilesExpand file tree

_index.md

Latest commit

History