porovnání dokumentů .net – Kompletní průvodce implementací GroupDocs

Pokud potřebujete porovnání dokumentů .net, jste na správném místě. Představte si, že otevřete dvě smlouvy, které vypadají identicky, a okamžitě odhalíte každou změnu—žádné ruční posouvání, žádné přehlédnuté úpravy. To je síla automatizovaného porovnávání dokumentů a s GroupDocs.Comparison for .NET to můžete zvládnout během několika minut.

Rychlé odpovědi

  • Jaká knihovna provádí porovnání dokumentů v .NET? GroupDocs.Comparison.
  • Mohu porovnávat soubory Word, Excel a PDF? Ano—podporováno je více než 50 formátů.
  • Kterou verzi mám použít? Verze 25.4.0 nabízí nejlepší výkon a stabilitu.
  • Potřebuji licenci pro produkci? Pro nasazení do produkce je vyžadována komerční licence.
  • Je možné asynchronní zpracování? Rozhodně—použijte Task.Run s API pro porovnání.

Co je GroupDocs.Comparison?

GroupDocs.Comparison je .NET knihovna, která programově detekuje rozdíly mezi dvěma nebo více dokumenty a generuje zvýrazněný výsledný soubor. Podporuje více než 50 formátů, zpracovává soubory s několika stovkami stránek, aniž by načítala celý obsah do paměti, a poskytuje detailní kontrolu nad nastavením porovnání.

Proč použít GroupDocs.Comparison pro porovnání dokumentů .net?

GroupDocs.Comparison poskytuje rychlé, přesné a škálovatelné porovnávání dokumentů pro .NET aplikace. Dokáže během několika sekund zpracovat velké PDF a Office soubory, zachovat formátování a vizuální věrnost a zároveň zvýraznit vložení, smazání a změny stylu. Knihovna funguje napříč .NET Core, .NET 5/6/7 a plným .NET Frameworkem, což z ní činí univerzální volbu pro jakýkoli projekt.

  • Rychlost: Zpracuje 200‑stránkový PDF za méně než 2 sekundy na standardním serveru.
  • Přesnost: Detekuje text, formátování, tabulky a obrázky s 99,9 % věrností.
  • Škálovatelnost: Zvládá dávkové úlohy tisíců souborů pomocí streamingových API.
  • Flexibilita: Funguje s .NET Core 3.1+, .NET 5/6/7 a .NET Framework 4.6.1+.

Předpoklady

  • Vývojové prostředí: .NET Core 3.1 nebo novější, nebo .NET Framework 4.6.1 +
  • Knihovna GroupDocs.Comparison: Verze 25.4.0 (nainstalována přes NuGet)
  • Ukázkové soubory: Word, PDF nebo Excel dokumenty pro testování
  • Základní znalost C#: Třídy, metody, using příkazy

Doporučené (volitelné)

  • Znalost správy balíčků NuGet
  • Zkušenost se souborovým I/O a streamy
  • Porozumění vzorům async/await

Jak porovnat dokumenty .net pomocí GroupDocs.Comparison?

Pro porovnání dvou dokumentů pomocí GroupDocs.Comparison načtěte každý soubor do streamu, nakonfigurujte volitelná ComparisonSettings a zavolejte metodu Compare na instanci Comparer. API vrátí výsledný dokument, který zvýrazní rozdíly, a můžete jej uložit do libovolného podporovaného formátu. Tento přístup vyžaduje jen několik řádků kódu a poskytuje plnou kontrolu nad procesem porovnání.

Implementace krok za krokem

1️⃣ Inteligentní správa cest k dokumentům

Centralizace cest k souborům zabraňuje chybám „soubor nenalezen“ a usnadňuje přepínání prostředí.

public static class Constants
{
    public const string SOURCE_WORD = @"YOUR_DOCUMENT_DIRECTORY\source.docx";
    public const string TARGET_WORD = @"YOUR_DOCUMENT_DIRECTORY\target.docx";

    public static string GetOutputDirectoryPath()
    {
        return @"YOUR_OUTPUT_DIRECTORY";
    }

    public const string RESULT_WORD = "result.docx";
}

Proč to funguje:

  • Jedno místo pro aktualizaci cest pro vývoj, test nebo produkci.
  • Odstraňuje pevně zakódované řetězce roztroušené po celém kódu.

2️⃣ Jádrová logika porovnání

Třída Comparer je motor, který řídí algoritmus diff.

using (Comparer comparer = new Comparer(Constants.SOURCE_WORD))
{
    // Add the target document for comparison
    comparer.Add(Constants.TARGET_WORD);

    // Perform the comparison and save the result
    string outputFileName = Path.Combine(Constants.GetOutputDirectoryPath(), Constants.RESULT_WORD);
    comparer.Compare(outputFileName);
}

Definiční kotva:
Comparer je hlavní třída GroupDocs.Comparison, která orchestruje analýzu dokumentu a vytváří zvýrazněný výsledek.

Jak pomáhá:

  • Podporuje více cílových dokumentů pomocí opakovaných volání Add().
  • Generuje výstupní soubor se změnami zvýrazněnými červeně, zeleně nebo vlastními barvami.

3️⃣ Pokročilá nastavení pro Excel a PDF

Můžete jemně doladit porovnání tak, aby ignorovalo formátování nebo se zaměřilo na změny dat—ideální pro scénáře compare excel files c#.

CompareOptions compareOptions = new CompareOptions()
{
    ShowDeletedContent = true,
    ShowInsertedContent = true,
    StyleChangeDetection = true
};

using (Comparer comparer = new Comparer(sourcePath))
{
    comparer.Add(targetPath);
    comparer.Compare(outputPath, compareOptions);
}

Definiční kotva:
ComparisonSettings vám umožňuje povolit nebo zakázat konkrétní typy změn, jako jsou DetectStyleChanges nebo DetectTableChanges.

4️⃣ Zpracování více formátů

GroupDocs.Comparison automaticky detekuje typ souboru, ale můžete také vynutit formát, pokud je to potřeba—ideální pro compare pdf files c#.

public static void CompareDocumentsByType(string sourcePath, string targetPath, string outputPath)
{
    string extension = Path.GetExtension(sourcePath).ToLower();
    
    using (Comparer comparer = new Comparer(sourcePath))
    {
        comparer.Add(targetPath);
        
        CompareOptions options = GetOptionsForFormat(extension);
        comparer.Compare(outputPath, options);
    }
}

private static CompareOptions GetOptionsForFormat(string extension)
{
    switch (extension)
    {
        case ".pdf":
            return new CompareOptions { DetectStyleChanges = false };
        case ".xlsx":
            return new CompareOptions { CalculateCoordinates = true };
        default:
            return new CompareOptions();
    }
}

5️⃣ Streamování velkých souborů

Při zpracování obrovských dokumentů streamování zabraňuje načítání celého souboru do paměti.

// For files over 50MB, consider this approach
using (var sourceStream = File.OpenRead(sourcePath))
using (var targetStream = File.OpenRead(targetPath))
using (var comparer = new Comparer(sourceStream))
{
    comparer.Add(targetStream);
    comparer.Compare(outputStream);
}

6️⃣ Robustní zpracování chyb

Nenechte poškozený soubor zhrouznout vaši službu; obalte volání do bloků try‑catch a zaznamenejte užitečné podrobnosti.

try
{
    using (Comparer comparer = new Comparer(sourcePath))
    {
        comparer.Add(targetPath);
        comparer.Compare(outputPath);
    }
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"Document not found: {ex.FileName}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"Access denied: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Comparison failed: {ex.Message}");
}

Nejlepší postupy pro porovnávání dokumentů

  • Ověřte vstupní soubory před voláním API, abyste včas zachytili nepodporované formáty.
  • Použijte Path.Combine pro konstrukci cest napříč platformami (viz Úskalí #1).
  • Povolte jen potřebné typy změn pro zlepšení výkonu (např. zakázat detekci stylu u Excel tabulek zaměřených na data).
  • Okamžitě uvolněte objekty Comparer pro uvolnění nativních zdrojů.

Časté úskalí a jak se jim vyhnout

Úskalí #1: Problémy s oddělovači cest

Řešení: Vždy vytvářejte cesty pomocí Path.Combine() a Path.DirectorySeparatorChar.

// Wrong - will break on different operating systems
string path = "C:/Documents/source.docx";

// Right - works everywhere
string path = Path.Combine("C:", "Documents", "source.docx");

Úskalí #2: Vyčerpání paměti u velkých souborů

Řešení: Přepněte do režimu streamování pro soubory větší než 50 MB.

// For files over 50MB, consider this approach
using (var sourceStream = File.OpenRead(sourcePath))
using (var targetStream = File.OpenRead(targetPath))
using (var comparer = new Comparer(sourceStream))
{
    comparer.Add(targetStream);
    comparer.Compare(outputStream);
}

Úskalí #3: Ignorování výjimek

Řešení: Implementujte komplexní bloky try‑catch a zaznamenávejte stack trace.

try
{
    using (Comparer comparer = new Comparer(sourcePath))
    {
        comparer.Add(targetPath);
        comparer.Compare(outputPath);
    }
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"Document not found: {ex.FileName}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"Access denied: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Comparison failed: {ex.Message}");
}

Strategie optimalizace výkonu

Správa paměti

Znovu použijte instance Comparer, pokud je to možné, a po každém porovnání zavolejte Dispose().

// Always dispose of resources properly
using (var comparer = new Comparer(sourcePath))
{
    comparer.Add(targetPath);
    comparer.Compare(outputPath);
    
    // Comparer is automatically disposed here
}

// For batch processing, clear resources between comparisons
for (int i = 0; i < documentPairs.Count; i++)
{
    using (var comparer = new Comparer(documentPairs[i].Source))
    {
        comparer.Add(documentPairs[i].Target);
        comparer.Compare(documentPairs[i].Output);
    }
    
    // Force garbage collection every 10 documents if needed
    if (i % 10 == 0)
    {
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

Asynchronní zpracování

Spouštějte porovnání na vláknech na pozadí, aby UI zůstalo responzivní.

public async Task<bool> CompareDocumentsAsync(string sourcePath, string targetPath, string outputPath)
{
    return await Task.Run(() =>
    {
        try
        {
            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(outputPath);
                return true;
            }
        }
        catch
        {
            return false;
        }
    });
}

Integrace s populárními .NET frameworky

Integrace ASP.NET Core Web API

Zveřejněte REST endpoint, který přijímá dva soubory a vrací výsledek diff.

[ApiController]
[Route("api/[controller]")]
public class DocumentComparisonController : ControllerBase
{
    [HttpPost("compare")]
    public async Task<IActionResult> CompareDocuments([FromForm] IFormFile sourceFile, [FromForm] IFormFile targetFile)
    {
        if (sourceFile == null || targetFile == null)
            return BadRequest("Both source and target files are required.");

        var tempFolder = Path.GetTempPath();
        var sourcePath = Path.Combine(tempFolder, sourceFile.FileName);
        var targetPath = Path.Combine(tempFolder, targetFile.FileName);
        var outputPath = Path.Combine(tempFolder, $"comparison_{Guid.NewGuid()}.pdf");

        try
        {
            // Save uploaded files
            using (var stream = new FileStream(sourcePath, FileMode.Create))
                await sourceFile.CopyToAsync(stream);
            
            using (var stream = new FileStream(targetPath, FileMode.Create))
                await targetFile.CopyToAsync(stream);

            // Perform comparison
            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(outputPath);
            }

            // Return the result file
            var fileBytes = await System.IO.File.ReadAllBytesAsync(outputPath);
            return File(fileBytes, "application/pdf", "comparison_result.pdf");
        }
        finally
        {
            // Clean up temp files
            File.Delete(sourcePath);
            File.Delete(targetPath);
            File.Delete(outputPath);
        }
    }
}

Integrace komponenty Blazor

Vytvořte znovupoužitelnou komponentu, která zobrazuje porovnání vedle sebe v prohlížeči.

@using GroupDocs.Comparison
@inject IJSRuntime JSRuntime

<div class="document-comparison">
    <InputFile OnChange="HandleFileSelection" multiple />
    <button @onclick="CompareDocuments" disabled="@(!CanCompare)">Compare Documents</button>
    
    @if (comparisonResult != null)
    {
        <div class="result">
            <a href="@comparisonResult" download="comparison_result.pdf">Download Result</a>
        </div>
    }
</div>

@code {
    private List<IBrowserFile> selectedFiles = new();
    private string comparisonResult;
    
    private bool CanCompare => selectedFiles.Count == 2;

    private async Task HandleFileSelection(InputFileChangeEventArgs e)
    {
        selectedFiles = e.GetMultipleFiles(2).ToList();
    }

    private async Task CompareDocuments()
    {
        if (selectedFiles.Count != 2) return;

        // Implementation similar to Web API example
        // Save files, compare, and generate result
    }
}

Reálné příklady použití

Scénář 1: Revize právních smluv

Právnické firmy mohou automaticky zvýraznit přidání, smazání a změny formátování napříč revizemi smluv.

public class ContractReviewService
{
    public ContractComparisonResult ReviewContract(string originalContract, string revisedContract)
    {
        var outputPath = Path.Combine(Path.GetTempPath(), $"contract_review_{DateTime.Now:yyyyMMddHHmmss}.docx");
        
        var compareOptions = new CompareOptions
        {
            ShowDeletedContent = true,
            ShowInsertedContent = true,
            StyleChangeDetection = true,
            WordsSeparatorChars = new[] { ' ', '.', ',', '!', '?' }
        };

        using (var comparer = new Comparer(originalContract))
        {
            comparer.Add(revisedContract);
            comparer.Compare(outputPath, compareOptions);
        }

        return new ContractComparisonResult
        {
            OutputPath = outputPath,
            HasChanges = File.Exists(outputPath),
            ComparisonDate = DateTime.Now
        };
    }
}

Scénář 2: Správa verzí pro tabulky

Finanční týmy mohou detekovat změny v Excel modelech bez nutnosti ručně otevírat každý soubor.

public class DocumentVersionControl
{
    public void TrackDocumentChanges(string documentPath, string repositoryPath)
    {
        var versions = Directory.GetFiles(repositoryPath, "*.docx").OrderBy(f => f);
        var latestVersion = versions.LastOrDefault();

        if (latestVersion != null)
        {
            var comparisonPath = Path.Combine(repositoryPath, $"changes_{DateTime.Now:yyyyMMdd}.docx");
            
            using (var comparer = new Comparer(latestVersion))
            {
                comparer.Add(documentPath);
                comparer.Compare(comparisonPath);
            }

            // Archive the comparison for future reference
            ArchiveComparison(comparisonPath);
        }
    }

    private void ArchiveComparison(string comparisonPath)
    {
        // Implementation for archiving comparison results
        var archivePath = Path.Combine(Path.GetDirectoryName(comparisonPath), "archive", Path.GetFileName(comparisonPath));
        Directory.CreateDirectory(Path.GetDirectoryName(archivePath));
        File.Move(comparisonPath, archivePath);
    }
}

Průvodce řešením problémů

Problém 1: „Formát souboru není podporován“

Řešení: Ověřte příponu souboru vůči seznamu podporovaných (více než 50 formátů) a nejprve převádějte nepodporované typy do PDF.

private static readonly HashSet<string> SupportedFormats = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
    ".docx", ".doc", ".pdf", ".xlsx", ".xls", ".pptx", ".ppt", ".txt", ".rtf"
};

public static bool IsFormatSupported(string filePath)
{
    var extension = Path.GetExtension(filePath);
    return SupportedFormats.Contains(extension);
}

Problém 2: Problémy s pamětí u velkých souborů

Řešení: Povolit streamování a zpracovávat soubory po částech.

public static void CompareLargeDocuments(string sourcePath, string targetPath, string outputPath)
{
    var fileInfo = new FileInfo(sourcePath);
    
    if (fileInfo.Length > 50 * 1024 * 1024) // 50MB threshold
    {
        // Use streaming approach
        using (var sourceStream = File.OpenRead(sourcePath))
        using (var targetStream = File.OpenRead(targetPath))
        using (var outputStream = File.Create(outputPath))
        using (var comparer = new Comparer(sourceStream))
        {
            comparer.Add(targetStream);
            comparer.Compare(outputStream);
        }
    }
    else
    {
        // Standard approach for smaller files
        using (var comparer = new Comparer(sourcePath))
        {
            comparer.Add(targetPath);
            comparer.Compare(outputPath);
        }
    }
}

Problém 3: Prázdný výsledek porovnání

Řešení: Zvyšte citlivost přepnutím DetectFormattingChanges nebo DetectStyleChanges.

var compareOptions = new CompareOptions
{
    DetectStyleChanges = true,
    DiagramMasterSetting = new DiagramMasterSetting
    {
        UseSourceMaster = true,
        CloneSourceMaster = true
    },
    OriginalSize = new Size(600, 800),
    HeaderFootersComparison = true,
    PaperSize = PaperSize.A4
};

Často kladené otázky

Q: Kolik dokumentů mohu porovnat najednou?
A: Můžete přidat více cílových dokumentů do jedné instance Comparer pomocí opakovaných volání Add(), ale pro velké dávky se doporučuje zpracovávat je sekvenčně.

Q: Dokáže GroupDocs.Comparison pracovat se soubory chráněnými heslem?
A: Ano—při vytváření Comparer nebo načítání dokumentu předáte heslo.

using (var comparer = new Comparer(sourcePath, new LoadOptions("password")))
{
    comparer.Add(targetPath, new LoadOptions("targetPassword"));
    comparer.Compare(outputPath);
}

Q: Jaké formáty souborů GroupDocs.Comparison podporuje?
A: Více než 50 formátů, včetně DOCX, XLSX, PPTX, PDF, JPEG, PNG, TXT a dalších.

Q: Jak mohu přizpůsobit vzhled změn?
A: Použijte ComparisonSettings k nastavení InsertedColor, DeletedColor a StyleChangeColor.

var compareOptions = new CompareOptions
{
    InsertedItemStyle = new StyleSettings
    {
        HighlightColor = Color.Green,
        FontColor = Color.DarkGreen
    },
    DeletedItemStyle = new StyleSettings
    {
        HighlightColor = Color.Red,
        FontColor = Color.DarkRed
    }
};

Q: Je možné ignorovat konkrétní typy změn?
A: Rozhodně—v ComparisonSettings zakážete možnosti jako DetectStyleChanges nebo DetectTableChanges.

var compareOptions = new CompareOptions
{
    DetectStyleChanges = false, // Ignore formatting changes
    HeaderFootersComparison = false, // Skip headers/footers
    WordsSeparatorChars = new[] { ' ', '\n', '\r', '\t' } // Define word boundaries
};

Q: Mohu porovnávat dokumenty uložené v cloudovém úložišti?
A: Ano—stáhněte streamy lokálně nebo porovnávejte přímo z MemoryStream.

using (var sourceStream = await DownloadFromCloudAsync(sourceUrl))
using (var targetStream = await DownloadFromCloudAsync(targetUrl))
using (var comparer = new Comparer(sourceStream))
{
    comparer.Add(targetStream);
    comparer.Compare(outputStream);
}

Q: Jak spustím GroupDocs.Comparison uvnitř Docker kontejneru?
A: Zahrňte potřebné nativní závislosti do svého Dockerfile a zkopírujte licenční soubor do kontejneru.

FROM mcr.microsoft.com/dotnet/aspnet:6.0
# Install necessary fonts and libraries for document processing
RUN apt-get update && apt-get install -y libfontconfig1 libfreetype6

Q: Jaká licence je vyžadována pro produkci?
A: Pro nasazení do produkce je povinná komerční licence GroupDocs.Comparison. Možnosti zahrnují vývojářskou, site a OEM licence.

Q: Jak mám elegantně zacházet s neúspěchy porovnání?
A: Obalte volání porovnání do bloku try‑catch, zaznamenejte výjimku a vraťte uživatelsky přívětivou chybovou zprávu.

public async Task<ComparisonResult> CompareDocumentsWithRetry(string source, string target, int maxRetries = 3)
{
    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            using (var comparer = new Comparer(source))
            {
                comparer.Add(target);
                var outputPath = GenerateOutputPath();
                comparer.Compare(outputPath);
                
                return new ComparisonResult { Success = true, OutputPath = outputPath };
            }
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            _logger.LogWarning($"Comparison attempt {attempt} failed: {ex.Message}. Retrying...");
            await Task.Delay(TimeSpan.FromSeconds(attempt * 2)); // Exponential backoff
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"Comparison failed after {maxRetries} attempts");
            return new ComparisonResult { Success = false, Error = ex.Message };
        }
    }
    
    return new ComparisonResult { Success = false, Error = "Max retries exceeded" };
}

Důležité zdroje a dokumentace

Poslední aktualizace: 2026-06-10
Testováno s: GroupDocs.Comparison 25.4.0 for .NET
Autor: GroupDocs

Install-Package GroupDocs.Comparison -Version 25.4.0

dotnet add package GroupDocs.Comparison --version 25.4.0

using GroupDocs.Comparison;

Související tutoriály