Dokumente vergleichen .net – Vollständiger GroupDocs Implementierungsleitfaden

Wenn Sie Dokumente vergleichen .net müssen, sind Sie hier genau richtig. Stellen Sie sich vor, Sie öffnen zwei Verträge, die identisch aussehen, und erkennen sofort jede Änderung – kein manuelles Scrollen, keine übersehenen Änderungen. Das ist die Kraft des automatisierten Dokumentenvergleichs, und mit GroupDocs.Comparison für .NET können Sie das in wenigen Minuten erreichen.

Schnelle Antworten

  • Welche Bibliothek führt den Dokumentenvergleich in .NET durch? GroupDocs.Comparison.
  • Kann ich Word-, Excel- und PDF-Dateien vergleichen? Ja – über 50 Formate werden unterstützt.
  • Welche Version sollte ich verwenden? Version 25.4.0 bietet die beste Leistung und Stabilität.
  • Benötige ich eine Lizenz für die Produktion? Für Produktionsumgebungen ist eine kommerzielle Lizenz erforderlich.
  • Ist asynchrone Verarbeitung möglich? Absolut – verwenden Sie Task.Run mit der Vergleichs‑API.

Was ist GroupDocs.Comparison?

GroupDocs.Comparison ist eine .NET‑Bibliothek, die programmgesteuert Unterschiede zwischen zwei oder mehreren Dokumenten erkennt und eine hervorgehobene Ergebnisdatei erzeugt. Sie unterstützt mehr als 50 Formate, verarbeitet mehrseitige Dateien, ohne den gesamten Inhalt in den Speicher zu laden, und bietet feinkörnige Kontrolle über die Vergleichseinstellungen.

Warum GroupDocs.Comparison für compare documents .net verwenden?

GroupDocs.Comparison liefert schnellen, genauen und skalierbaren Dokumenten‑Diff für .NET‑Anwendungen. Es kann große PDFs und Office‑Dateien in Sekunden verarbeiten, das Layout und die visuelle Treue bewahren und Einfügungen, Löschungen sowie Stiländerungen hervorheben. Die Bibliothek funktioniert unter .NET Core, .NET 5/6/7 und dem vollständigen .NET Framework und ist damit eine vielseitige Wahl für jedes Projekt.

  • Geschwindigkeit: Verarbeitet ein 200‑seitiges PDF in unter 2 Sekunden auf einem Standard‑Server.
  • Genauigkeit: Erkennt Text, Formatierung, Tabellen und Bilder mit 99,9 % Treue.
  • Skalierbarkeit: Bewältigt Batch‑Jobs mit Tausenden von Dateien über Streaming‑APIs.
  • Flexibilität: Arbeitet mit .NET Core 3.1+, .NET 5/6/7 und .NET Framework 4.6.1+.

Voraussetzungen

  • Entwicklungsumgebung: .NET Core 3.1 oder neuer, oder .NET Framework 4.6.1 +
  • GroupDocs.Comparison‑Bibliothek: Version 25.4.0 (via NuGet installiert)
  • Beispieldateien: Word-, PDF‑ oder Excel‑Dokumente zum Testen
  • Grundkenntnisse in C#: Klassen, Methoden, using‑Anweisungen

Nice‑to‑Have (Optional)

  • Vertrautheit mit NuGet‑Paketverwaltung
  • Erfahrung mit Datei‑I/O und Streams
  • Verständnis von async/await‑Mustern

Wie vergleicht man Dokumente .net mit GroupDocs.Comparison?

Um zwei Dokumente mit GroupDocs.Comparison zu vergleichen, laden Sie jede Datei in einen Stream, konfigurieren optionale ComparisonSettings und rufen die Compare‑Methode einer Comparer‑Instanz auf. Die API liefert ein Ergebnisdokument, das die Unterschiede hervorhebt, und Sie können es in jedem unterstützten Format speichern. Dieser Ansatz erfordert nur wenige Code‑Zeilen und gibt Ihnen volle Kontrolle über den Vergleichsprozess.

Schritt‑für‑Schritt‑Implementierung

1️⃣ Smart Document Path Management

Die Zentralisierung von Dateipfaden verhindert „Datei nicht gefunden“-Fehler und macht Umgebungswechsel mühelos.

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

Warum das funktioniert:

  • Eine zentrale Stelle, um Pfade für Entwicklung, Test oder Produktion zu aktualisieren.
  • Entfernt hartkodierte Zeichenketten, die im gesamten Code verstreut sind.

2️⃣ Kern‑Vergleichslogik

Die Klasse Comparer ist die Engine, die den Diff‑Algorithmus antreibt.

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

Definition:
Comparer ist die Kernklasse von GroupDocs.Comparison, die die Dokumentenanalyse orchestriert und das hervorgehobene Ergebnis erzeugt.

Wie es hilft:

  • Unterstützt mehrere Ziel‑Dokumente über wiederholte Add()‑Aufrufe.
  • Erzeugt eine Ergebnisdatei, in der Änderungen rot, grün oder in benutzerdefinierten Farben hervorgehoben werden.

3️⃣ Erweiterte Einstellungen für Excel und PDF

Sie können den Vergleich feinjustieren, um Formatierungen zu ignorieren oder sich auf Datenänderungen zu konzentrieren – ideal für compare excel files c#‑Szenarien.

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

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

Definition:
ComparisonSettings ermöglicht das Aktivieren oder Deaktivieren bestimmter Änderungstypen wie DetectStyleChanges oder DetectTableChanges.

4️⃣ Umgang mit mehreren Formaten

GroupDocs.Comparison erkennt den Dateityp automatisch, Sie können jedoch bei Bedarf ein Format erzwingen – ideal für 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️⃣ Streaming großer Dateien

Beim Verarbeiten riesiger Dokumente verhindert Streaming das Laden der gesamten Datei in den Speicher.

// 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️⃣ Robuste Fehlerbehandlung

Lassen Sie nie zu, dass eine beschädigte Datei Ihren Service zum Absturz bringt; umschließen Sie Aufrufe in try‑catch‑Blöcken und protokollieren Sie nützliche Details.

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

Best Practices für den Dokumentenvergleich

  • Eingabedateien validieren bevor die API aufgerufen wird, um nicht unterstützte Formate früh zu erkennen.
  • Path.Combine verwenden für plattformübergreifende Pfadkonstruktion (siehe Problem #1).
  • Nur benötigte Änderungstypen aktivieren, um die Leistung zu steigern (z. B. Stil‑Erkennung für daten‑zentrierte Excel‑Sheets deaktivieren).
  • Comparer‑Objekte sofort freigeben, um native Ressourcen zu schonen.

Häufige Stolperfallen und wie man sie vermeidet

Problem #1: Pfad‑Separator‑Probleme

Lösung: Pfade immer mit Path.Combine() und Path.DirectorySeparatorChar zusammenbauen.

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

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

Problem #2: Speichererschöpfung bei großen Dateien

Lösung: Für Dateien größer als 50 MB in den Streaming‑Modus wechseln.

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

Problem #3: Ignorieren von Ausnahmen

Lösung: Umfassende try‑catch‑Blöcke implementieren und Stack‑Traces protokollieren.

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

Strategien zur Leistungsoptimierung

Speicherverwaltung

Comparer‑Instanzen nach Möglichkeit wiederverwenden und nach jedem Vergleich Dispose() aufrufen.

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

Asynchrone Verarbeitung

Vergleiche in Hintergrund‑Threads ausführen, um die UI reaktionsfähig zu halten.

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

Integration in beliebte .NET‑Frameworks

ASP.NET Core Web‑API‑Integration

Stellen Sie einen REST‑Endpunkt bereit, der zwei Dateien entgegennimmt und das Diff‑Ergebnis zurückgibt.

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

Blazor‑Komponenten‑Integration

Erstellen Sie eine wiederverwendbare Komponente, die den Seiten‑zu‑Seiten‑Vergleich im Browser anzeigt.

@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
    }
}

Praxisbeispiele

Szenario 1: Juristische Vertragsprüfung

Anwaltskanzleien können automatisch Ergänzungen, Löschungen und Formatänderungen über Vertragsrevisionen hinweg hervorheben.

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

Szenario 2: Versionskontrolle für Tabellenkalkulationen

Finanzteams können Änderungen in Excel‑Modellen erkennen, ohne jede Datei manuell zu öffnen.

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

Fehlersuch‑Leitfaden

Problem 1: „Dateiformat nicht unterstützt“

Lösung: Die Dateierweiterung mit der unterstützten Liste (50+ Formate) abgleichen und nicht unterstützte Typen zunächst in PDF konvertieren.

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

Problem 2: Speicherprobleme bei großen Dateien

Lösung: Streaming aktivieren und Dateien in Chunks verarbeiten.

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

Problem 3: Leeres Vergleichsergebnis

Lösung: Die Empfindlichkeit erhöhen, indem Sie DetectFormattingChanges oder DetectStyleChanges umschalten.

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

Häufig gestellte Fragen

F: Wie viele Dokumente kann ich gleichzeitig vergleichen?
A: Sie können mehrere Ziel‑Dokumente zu einer einzigen Comparer‑Instanz hinzufügen, indem Sie wiederholt Add() aufrufen. Für große Stapel wird jedoch eine sequenzielle Verarbeitung empfohlen.

F: Kann GroupDocs.Comparison passwortgeschützte Dateien verarbeiten?
A: Ja – übergeben Sie das Passwort beim Erzeugen des Comparer oder beim Laden des Dokuments.

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

F: Welche Dateiformate unterstützt GroupDocs.Comparison?
A: Über 50 Formate, darunter DOCX, XLSX, PPTX, PDF, JPEG, PNG, TXT und mehr.

F: Wie passe ich das Aussehen von Änderungen an?
A: Verwenden Sie ComparisonSettings, um InsertedColor, DeletedColor und StyleChangeColor festzulegen.

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

F: Ist es möglich, bestimmte Änderungstypen zu ignorieren?
A: Absolut – deaktivieren Sie Optionen wie DetectStyleChanges oder DetectTableChanges in ComparisonSettings.

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

F: Kann ich Dokumente vergleichen, die in Cloud‑Speichern liegen?
A: Ja – laden Sie die Streams lokal herunter oder vergleichen Sie direkt aus einem 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);
}

F: Wie führe ich GroupDocs.Comparison in einem Docker‑Container aus?
A: Die erforderlichen nativen Abhängigkeiten in das Dockerfile aufnehmen und die Lizenzdatei in den Container kopieren.

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

F: Welche Lizenzierung ist für die Produktion nötig?
A: Für Produktions‑Deployments ist eine kommerzielle GroupDocs.Comparison‑Lizenz zwingend erforderlich. Optionen umfassen Entwickler‑, Site‑ und OEM‑Lizenzen.

F: Wie sollte ich Vergleichsfehler elegant behandeln?
A: Den Vergleichsaufruf in einen try‑catch‑Block einbetten, die Ausnahme protokollieren und eine benutzerfreundliche Fehlermeldung zurückgeben.

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

Wichtige Ressourcen und Dokumentation

Zuletzt aktualisiert: 2026-06-10
Getestet mit: GroupDocs.Comparison 25.4.0 für .NET
Autor: GroupDocs

Install-Package GroupDocs.Comparison -Version 25.4.0

dotnet add package GroupDocs.Comparison --version 25.4.0

using GroupDocs.Comparison;

Verwandte Tutorials