Σύγκριση εγγράφων .net – Πλήρης Οδηγός Υλοποίησης GroupDocs

Αν χρειάζεστε compare documents .net, ήρθατε στο σωστό μέρος. Φανταστείτε ότι ανοίγετε δύο συμβάσεις που φαίνονται πανομοιότυπες και εντοπίζετε αμέσως κάθε αλλαγή—χωρίς χειροκίνητη κύλιση, χωρίς χαμένες επεμβάσεις. Αυτή είναι η δύναμη της αυτοματοποιημένης σύγκρισης εγγράφων, και με GroupDocs.Comparison for .NET μπορείτε να το επιτύχετε σε λίγα λεπτά.

Γρήγορες Απαντήσεις

  • Ποια βιβλιοθήκη διαχειρίζεται τη σύγκριση εγγράφων σε .NET; GroupDocs.Comparison.
  • Μπορώ να συγκρίνω αρχεία Word, Excel και PDF; Ναι—υποστηρίζονται πάνω από 50 μορφές.
  • Ποια έκδοση πρέπει να χρησιμοποιήσω; Η έκδοση 25.4.0 προσφέρει την καλύτερη απόδοση και σταθερότητα.
  • Χρειάζομαι άδεια για παραγωγή; Απαιτείται εμπορική άδεια για παραγωγικές εγκαταστάσεις.
  • Είναι δυνατή η ασύγχρονη επεξεργασία; Απόλυτα—χρησιμοποιήστε Task.Run με το API σύγκρισης.

Τι είναι το GroupDocs.Comparison;

Το GroupDocs.Comparison είναι μια βιβλιοθήκη .NET που ανιχνεύει προγραμματιστικά διαφορές μεταξύ δύο ή περισσότερων εγγράφων και δημιουργεί ένα αρχείο αποτελέσματος με επισήμανση. Υποστηρίζει πάνω από 50 μορφές, επεξεργάζεται αρχεία με εκατοντάδες σελίδες χωρίς να φορτώνει ολόκληρο το περιεχόμενο στη μνήμη, και παρέχει λεπτομερή έλεγχο των ρυθμίσεων σύγκρισης.

Γιατί να χρησιμοποιήσετε το GroupDocs.Comparison για compare documents .net;

Το GroupDocs.Comparison παρέχει γρήγορη, ακριβή και κλιμακώσιμη σύγκριση εγγράφων για εφαρμογές .NET. Μπορεί να επεξεργαστεί μεγάλα PDF και αρχεία Office σε δευτερόλεπτα, διατηρώντας τη μορφοποίηση και την οπτική πιστότητα ενώ επισημαίνει προσθήκες, διαγραφές και αλλαγές στυλ. Η βιβλιοθήκη λειτουργεί σε .NET Core, .NET 5/6/7 και το πλήρες .NET Framework, καθιστώντας την ευέλικτη επιλογή για οποιοδήποτε έργο.

  • Ταχύτητα: Επεξεργάζεται ένα PDF 200 σελίδων σε λιγότερο από 2 δευτερόλεπτα σε έναν τυπικό διακομιστή.
  • Ακρίβεια: Ανιχνεύει κείμενο, μορφοποίηση, πίνακες και εικόνες με 99,9 % πιστότητα.
  • Κλιμακωσιμότητα: Διαχειρίζεται παρτίδες χιλιάδων αρχείων χρησιμοποιώντας streaming APIs.
  • Ευελιξία: Λειτουργεί με .NET Core 3.1+, .NET 5/6/7, και .NET Framework 4.6.1+.

Προαπαιτούμενα

  • Περιβάλλον Ανάπτυξης: .NET Core 3.1 ή νεότερο, ή .NET Framework 4.6.1 +
  • Βιβλιοθήκη GroupDocs.Comparison: Έκδοση 25.4.0 (εγκατεστημένη μέσω NuGet)
  • Δείγμα Αρχείων: Έγγραφα Word, PDF ή Excel για δοκιμές
  • Βασικές Γνώσεις C#: Κλάσεις, μέθοδοι, δηλώσεις using

Επιθυμητό (Προαιρετικό)

  • Εξοικείωση με τη διαχείριση πακέτων NuGet
  • Εμπειρία με I/O αρχείων και streams
  • Κατανόηση των προτύπων async/await

Πώς να συγκρίνετε έγγραφα .net χρησιμοποιώντας το GroupDocs.Comparison;

Για να συγκρίνετε δύο έγγραφα με το GroupDocs.Comparison, φορτώστε κάθε αρχείο σε ένα stream, διαμορφώστε προαιρετικές ComparisonSettings και καλέστε τη μέθοδο Compare σε μια παρουσία του Comparer. Το API επιστρέφει ένα έγγραφο αποτελέσματος που επισημαίνει τις διαφορές, και μπορείτε να το αποθηκεύσετε σε οποιαδήποτε υποστηριζόμενη μορφή. Αυτή η προσέγγιση απαιτεί μόνο λίγες γραμμές κώδικα ενώ σας δίνει πλήρη έλεγχο της διαδικασίας σύγκρισης.

Υλοποίηση βήμα‑βήμα

1️⃣ Έξυπνη Διαχείριση Διαδρομών Εγγράφων

Η κεντρική διαχείριση των διαδρομών αρχείων αποτρέπει σφάλματα “file not found” και κάνει τις αλλαγές περιβάλλοντος χωρίς προβλήματα.

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

Γιατί λειτουργεί αυτό:

  • Ένα μόνο σημείο για ενημέρωση διαδρομών για dev, test ή production.
  • Αφαιρεί τις σκληρά κωδικοποιημένες συμβολοσειρές που διασκορπίζονται σε όλο τον κώδικα.

2️⃣ Κεντρική Λογική Σύγκρισης

Η κλάση Comparer είναι η μηχανή που τρέχει τον αλγόριθμο 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);
}

Αγκύρα ορισμού:
Comparer είναι η κεντρική κλάση του GroupDocs.Comparison που οργανώνει την ανάλυση εγγράφων και παράγει το επισημασμένο αποτέλεσμα.

Πώς βοηθά:

  • Υποστηρίζει πολλαπλά στοχευμένα έγγραφα μέσω επαναλαμβανόμενων κλήσεων Add().
  • Δημιουργεί ένα αρχείο αποτελέσματος με αλλαγές επισημασμένες σε κόκκινο, πράσινο ή προσαρμοσμένα χρώματα.

3️⃣ Προηγμένες Ρυθμίσεις για Excel και PDF

Μπορείτε να ρυθμίσετε λεπτομερώς τη σύγκριση ώστε να αγνοεί τη μορφοποίηση ή να εστιάζει σε αλλαγές δεδομένων—ιδανικό για σενάρια 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);
}

Αγκύρα ορισμού:
ComparisonSettings σας επιτρέπει να ενεργοποιήσετε ή να απενεργοποιήσετε συγκεκριμένους τύπους αλλαγών όπως DetectStyleChanges ή DetectTableChanges.

4️⃣ Διαχείριση Πολλαπλών Μορφών

Το GroupDocs.Comparison ανιχνεύει αυτόματα τον τύπο του αρχείου, αλλά μπορείτε επίσης να επιβάλλετε μια μορφή όταν χρειάζεται—ιδανικό για 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 Μεγάλων Αρχείων

Κατά την επεξεργασία τεράστιων εγγράφων, το streaming αποτρέπει τη φόρτωση ολόκληρου του αρχείου στη μνήμη.

// 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️⃣ Ασφαλής Διαχείριση Σφαλμάτων

Μην αφήνετε ποτέ ένα κατεστραμμένο αρχείο να καταρρεύσει την υπηρεσία σας· τυλίξτε τις κλήσεις σε μπλοκ try‑catch και καταγράψτε χρήσιμες λεπτομέρειες.

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

Καλές πρακτικές σύγκρισης εγγράφων

  • Επικυρώστε τα αρχεία εισόδου πριν καλέσετε το API για να εντοπίσετε άσυπτες μορφές νωρίς.
  • Χρησιμοποιήστε Path.Combine για δημιουργία διαδρομών δια‑πλατφόρμας (δείτε το Pitfall #1).
  • Ενεργοποιήστε μόνο τους απαιτούμενους τύπους αλλαγών για βελτίωση της απόδοσης (π.χ., απενεργοποιήστε την ανίχνευση στυλ για φύλλα Excel που εστιάζουν στα δεδομένα).
  • Αποδεσμεύστε άμεσα τα αντικείμενα Comparer για να ελευθερώσετε τους εγγενείς πόρους.

Συνηθισμένα Πίτσα και Πώς να τα Αποφύγετε

Πίτσα #1: Προβλήματα Διαχωριστή Διαδρομής

Λύση:
Πάντα δημιουργείτε διαδρομές με Path.Combine() και 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");

Πίτσα #2: Εξάντληση Μνήμης σε Μεγάλα Αρχεία

Λύση:
Μεταβείτε σε λειτουργία streaming για αρχεία μεγαλύτερα από 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);
}

Πίτσα #3: Αγνόηση Εξαίρεσεων

Λύση:
Υλοποιήστε ολοκληρωμένα μπλοκ try‑catch και καταγράψτε τα stack traces.

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

Στρατηγικές Βελτιστοποίησης Απόδοσης

Διαχείριση Μνήμης

Επαναχρησιμοποιήστε τις εμφανίσεις Comparer όταν είναι δυνατόν και καλέστε 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();
    }
}

Ασύγχρονη Επεξεργασία

Τρέξτε τις συγκρίσεις σε νήματα παρασκηνίου για να διατηρείται η ανταπόκριση του UI.

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

Ενσωμάτωση με Δημοφιλή .NET Frameworks

Ενσωμάτωση ASP.NET Core Web API

Αποκτήστε ένα REST endpoint που δέχεται δύο αρχεία και επιστρέφει το αποτέλεσμα 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);
        }
    }
}

Ενσωμάτωση Συστατικού Blazor

Δημιουργήστε ένα επαναχρησιμοποιήσιμο στοιχείο που εμφανίζει σύγκριση πλάι-πλάι στον περιηγητή.

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

Πραγματικές Περιπτώσεις Χρήσης

Σενάριο 1: Ανασκόπηση Νομικών Συμβάσεων

Οι νομικές εταιρείες μπορούν αυτόματα να επισημαίνουν προσθήκες, διαγραφές και αλλαγές μορφοποίησης σε διαφορετικές εκδόσεις συμβάσεων.

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

Σενάριο 2: Έλεγχος Εκδόσεων για Φύλλα Εργασίας

Οι ομάδες οικονομικών μπορούν να εντοπίζουν αλλαγές σε μοντέλα Excel χωρίς να ανοίγουν χειροκίνητα κάθε αρχείο.

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

Οδηγός Επίλυσης Προβλημάτων

Πρόβλημα 1: “File format not supported”

Λύση:
Επαληθεύστε την επέκταση του αρχείου έναντι της λίστας υποστηριζόμενων (πάνω από 50 μορφές) και μετατρέψτε τους μη υποστηριζόμενους τύπους σε 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);
}

Πρόβλημα 2: Προβλήματα Μνήμης με Μεγάλα Αρχεία

Λύση:
Ενεργοποιήστε το streaming και επεξεργαστείτε τα αρχεία σε τμήματα.

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

Πρόβλημα 3: Κενό Αποτέλεσμα Σύγκρισης

Λύση:
Αυξήστε την ευαισθησία εναλλάσσοντας DetectFormattingChanges ή DetectStyleChanges.

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

Συχνές Ερωτήσεις

Q: Πόσα έγγραφα μπορώ να συγκρίνω ταυτόχρονα;
Μπορείτε να προσθέσετε πολλαπλά στοχευμένα έγγραφα σε μια ενότητα Comparer χρησιμοποιώντας επαναλαμβανόμενες κλήσεις Add(), αλλά συνιστάται η επεξεργασία τους διαδοχικά για μεγάλες παρτίδες.

Q: Μπορεί το GroupDocs.Comparison να διαχειριστεί αρχεία με κωδικό πρόσβασης;
Ναι—παρέχετε τον κωδικό πρόσβασης κατά τη δημιουργία του Comparer ή τη φόρτωση του εγγράφου.

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

Q: Ποιες μορφές αρχείων υποστηρίζει το GroupDocs.Comparison;
Πάνω από 50 μορφές, συμπεριλαμβανομένων DOCX, XLSX, PPTX, PDF, JPEG, PNG, TXT και άλλων.

Q: Πώς προσαρμόζω την εμφάνιση των αλλαγών;
Χρησιμοποιήστε ComparisonSettings για να ορίσετε InsertedColor, DeletedColor και StyleChangeColor.

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

Q: Μπορεί να αγνοηθεί συγκεκριμένος τύπος αλλαγής;
Απόλυτα—απενεργοποιήστε επιλογές όπως DetectStyleChanges ή DetectTableChanges στο ComparisonSettings.

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

Q: Μπορώ να συγκρίνω έγγραφα αποθηκευμένα σε cloud storage;
Ναι—κατεβάστε τα streams τοπικά ή συγκρίνετε απευθείας από ένα 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: Πώς τρέχω το GroupDocs.Comparison μέσα σε Docker container;
Συμπεριλάβετε τις απαραίτητες εγγενείς εξαρτήσεις στο Dockerfile σας και αντιγράψτε το αρχείο άδειας μέσα στο container.

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: Τι άδεια απαιτείται για παραγωγή;
Μια εμπορική άδεια GroupDocs.Comparison είναι υποχρεωτική για παραγωγικές εγκαταστάσεις. Οι επιλογές περιλαμβάνουν άδειες developer, site και OEM.

Q: Πώς πρέπει να διαχειρίζομαι αποτυχίες σύγκρισης με ευγένεια;
Τυλίξτε την κλήση σύγκρισης σε μπλοκ try‑catch, καταγράψτε την εξαίρεση και επιστρέψτε ένα φιλικό προς τον χρήστη μήνυμα σφάλματος.

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

Βασικοί Πόροι και Τεκμηρίωση

Τελευταία Ενημέρωση: 2026-06-10
Δοκιμάστηκε Με: GroupDocs.Comparison 25.4.0 for .NET
Συγγραφέας: GroupDocs

Install-Package GroupDocs.Comparison -Version 25.4.0

dotnet add package GroupDocs.Comparison --version 25.4.0

using GroupDocs.Comparison;

Σχετικά Μαθήματα