Jak zachować metadane przy użyciu GroupDocs.Comparison w .NET

W tym samouczku dowiesz się jak zachować metadane podczas porównywania dwóch dokumentów przy użyciu GroupDocs.Comparison dla .NET. Zachowanie metadanych jest niezbędne dla zgodności prawnej, ścieżek audytu i współpracujących przepływów pracy, a biblioteka daje Ci precyzyjną kontrolę nad tym, które metadane dokumentu przetrwają w wyniku porównania.

Wprowadzenie

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

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

Szybkie odpowiedzi

  • Co oznacza „zachować metadane docelowe”? Zachowuje metadane (autor, data utworzenia, własne właściwości itp.) z dokumentu, który określisz jako docelowy 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? Wymagana jest licencja komercyjna do produkcji; darmowa wersja próbna wystarczy do nauki.
  • Czy funkcja działa z PDF i DOCX? Tak — wszystkie główne formaty Office i PDF obsługują zachowanie metadanych.

Dlaczego zachowanie metadanych ma znaczenie

Zanim przejdziemy do kodu, porozmawiajmy o tym, dlaczego zachowanie metadanych docelowych ma znaczenie. Metadane dokumentu to nie tylko „miły dodatek” — często są wymagane prawnie lub krytyczne dla biznesu:

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

Bez odpowiedniego postępowania możesz przypadkowo usunąć informacje, które budowano przez miesiące. Właśnie wtedy opcja zachowania metadanych docelowych błyszczy.

Wymagania wstępne

Wymagane biblioteki i wersje

  • GroupDocs.Comparison dla .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óre preferujesz).
  • Podstawowa znajomość C# (nic zbyt zaawansowanego, obiecuję!).
  • Dwa przykładowe dokumenty do testów (Word .docx sprawdza 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 koncepcjami przetwarzania dokumentów.
  • czym są metadane (autor, tytuł, własne właściwości itp.).

Gotowy? Skonfigurujmy to.

Konfigurowanie GroupDocs.Comparison dla .NET

Instalacja GroupDocs.Comparison jest prosta, ale istnieje kilka pułapek, na które trzeba uważać.

Opcje instalacji

Konsola Menedżera Pakietów NuGet (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 w Twoim projekcie.

Uzyskanie licencji

To miejsce, w którym wielu programistów początkowo się zacina. GroupDocs.Comparison nie jest darmowy, ale masz opcje:

  • Darmowa wersja próbna — pełna funkcjonalność przez 30 dni, idealna do oceny.
  • Licencja tymczasowa — wydłuczony okres oceny, jeśli potrzebujesz więcej czasu.
  • Licencja komercyjna — do użytku produkcyjnego (dostępne różne poziomy cenowe).

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

Podstawowa weryfikacja konfiguracji

Upewnijmy się, że wszystko działa, wykonują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 to się kompiluje bez błędów, możesz kontynuować. Jeśli nie, sprawdź ponownie instalację pakietu i instrukcje using.

Jak zachować metadane docelowe

Wczytaj pliki źródłowe i docelowe, a następnie poinformuj API, aby zachował metadane docelowego pliku w ostatecznym wyniku.

Bezpośrednia odpowiedź (40‑70 słów):
Aby zachować metadane docelowe, utwórz obiekt Comparer z dokumentem źródłowym, dodaj dokument docelowy za pomocą Add, ustaw CloneMetadataType = MetadataType.Target w ComparisonOptions, a na końcu wywołaj Compare. To instruuje GroupDocs.Comparison, aby skopiował autora, datę utworzenia, własne właściwości i wszystkie inne metadane z pliku docelowego do wygenerowanego wyniku.

Zrozumienie przepływu metadanych

Podczas typowego porównania:

  1. Dokument źródłowy dostarcza podstawową treść.
  2. Dokument docelowy dostarcza zmiany, z którymi porównujemy.
  3. Dokument wyjściowy łączy oba, ale które metadane wygrywają?

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: Zainicjalizuj obiekt comparer

Comparer jest główną klasą, która koordynuje proces porównania. Ładuje plik źródłowy, śledzi zmiany i generuje wynik.

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

Comparer.Add rejestruje plik zawierający zmiany, które chcesz porównać.

comparer.Add(targetFilePath);

Częsty błąd: Mylenie źródła i celu. Myśl o tym tak — źródło to Twoje „oryginał”, a cel to Twoja „zaktualizowana wersja”.

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

CloneMetadataType jest właściwością ComparisonOptions, która określa, które metadane dokumentu zostaną sklonowane do 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 moim ostatecznym wyniku.”

Pełny działający przykład

Oto wszystko razem w programie, który można uruchomić:

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, których należy unikać

  • Problemy ze ścieżkami plików — 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 instrukcjami using.

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

Zaawansowane scenariusze metadanych

Kiedy używać metadanych docelowych vs. źródłowych

ScenariuszPreferuj metadane docelowePreferuj metadane źródłowe
Potrzebne zaktualizowane informacje o autorze✅❌
Dokument oryginalny 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ównać z kilkoma dokumentami docelowymi, 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 prawne 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 zgodności korporacyjnej

W regulowanych branżach 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 „Plik nie znaleziony”

Najczęstszy problem. Debuguj przy użyciu wyraźnych kontroli:

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

Rozważania dotyczące wydajności i najlepsze praktyki

Zarządzanie pamięcią

GroupDocs.Comparison może zużywać do 300 MB RAM przy przetwarzaniu 100‑stronicowego PDF. Używaj instrukcji using, aby zapewnić zwolnienie zasobów i szybkie zwolnienie pamięci.

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

Dla aplikacji desktopowych lub webowych, otocz porównanie metodą asynchroniczną:

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) — pokaż postęp, aby UI pozostało responsywne.
  • Duże (> 10 MB) — zawsze używaj przetwarzania asynchronicznego i rozważ wywołanie GC, jak pokazano powyżej.

Integracja z większymi systemami

Integracja z ASP.NET Core

Poniżej znajduje się gotowy kontroler, który przyjmuje dwa przesłane 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

Q: Czy mogę zachować metadane z wielu dokumentów docelowych podczas porównywania?
A: When you add several target files, GroupDocs.Comparison uses the metadata from the first target document added. Add the document whose metadata you want to keep first in the chain.
Q: Co się stanie, jeśli dokument docelowy nie zawiera niektórych pól metadanych?
A: Only the metadata that exists in the target will be copied to the output. Missing fields are simply omitted; the comparison still succeeds.
Q: Jak obsłużyć dokumenty chronione hasłem?
A: LoadOptions specifies settings such as passwords for opening protected documents. Use a LoadOptions object with the password, then pass it to the Comparer constructor:

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

Q: Czy istnieje sposób, aby zachować tylko wybrane właściwości metadanych?
A: The current API preserves all metadata from the chosen source (Target or Source). For granular control you’d need to extract the properties after comparison and re‑apply them manually.
Q: Które formaty dokumentów obsługują zachowanie metadanych?
A: Most common business formats—DOCX, PDF, PPTX, XLSX, and many others—support metadata preservation. See the official docs for the full list.
Q: Gdzie mogę uzyskać pomoc, jeśli napotkam problemy?
A: Visit the GroupDocs Support Forum for community assistance, or contact GroupDocs support directly if you have a commercial license.

Dodatkowe zasoby

Last Updated: 2026-09-15
Tested with: GroupDocs.Comparison 25.4.0 for .NET
Author: GroupDocs

Powiązane samouczki