Comment comparer efficacement deux fichiers PDF à l'aide de C# avec IronPDF

Install-Package IronPdf

dotnet add package IronPdf

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

class PdfComparer
{
    public static void CompareSimple(string pdf1Path, string pdf2Path)
    {
        // Load two PDF documents with error handling
        var pdf1 = PdfDocument.FromFile(pdf1Path);
        var pdf2 = PdfDocument.FromFile(pdf2Path);

        // Extract text from both PDFs using IronPDF's extraction engine
        string text1 = pdf1.ExtractAllText();
        string text2 = pdf2.ExtractAllText();

        // Compare the two documents
        if (text1 == text2)
        {
            Console.WriteLine("PDF files are identical");
        }
        else
        {
            Console.WriteLine("PDFs have differences");
            // Find differences and calculate similarity
            double similarity = CalculateSimilarity(text1, text2);
            Console.WriteLine($"Comparison result: {similarity:P} similar");

            // Optional: Show character-level differences
            var differences = GetDetailedDifferences(text1, text2);
            Console.WriteLine($"Total character differences: {differences}");
        }
    }

    private static double CalculateSimilarity(string text1, string text2)
    {
        int maxLength = Math.Max(text1.Length, text2.Length);
        if (maxLength == 0) return 1.0;

        int differences = 0;
        int minLength = Math.Min(text1.Length, text2.Length);

        // Character-by-character comparison
        for (int i = 0; i < minLength; i++)
        {
            if (text1[i] != text2[i]) differences++;
        }

        // Account for length differences
        differences += Math.Abs(text1.Length - text2.Length);

        return 1.0 - (double)differences / maxLength;
    }

    private static int GetDetailedDifferences(string text1, string text2)
    {
        // Implementation for detailed difference tracking
        return Math.Abs(text1.Length - text2.Length);
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Class PdfComparer
    Public Shared Sub CompareSimple(pdf1Path As String, pdf2Path As String)
        ' Load two PDF documents with error handling
        Dim pdf1 = PdfDocument.FromFile(pdf1Path)
        Dim pdf2 = PdfDocument.FromFile(pdf2Path)

        ' Extract text from both PDFs using IronPDF's extraction engine
        Dim text1 As String = pdf1.ExtractAllText()
        Dim text2 As String = pdf2.ExtractAllText()

        ' Compare the two documents
        If text1 = text2 Then
            Console.WriteLine("PDF files are identical")
        Else
            Console.WriteLine("PDFs have differences")
            ' Find differences and calculate similarity
            Dim similarity As Double = CalculateSimilarity(text1, text2)
            Console.WriteLine($"Comparison result: {similarity:P} similar")

            ' Optional: Show character-level differences
            Dim differences = GetDetailedDifferences(text1, text2)
            Console.WriteLine($"Total character differences: {differences}")
        End If
    End Sub

    Private Shared Function CalculateSimilarity(text1 As String, text2 As String) As Double
        Dim maxLength As Integer = Math.Max(text1.Length, text2.Length)
        If maxLength = 0 Then Return 1.0

        Dim differences As Integer = 0
        Dim minLength As Integer = Math.Min(text1.Length, text2.Length)

        ' Character-by-character comparison
        For i As Integer = 0 To minLength - 1
            If text1(i) <> text2(i) Then differences += 1
        Next

        ' Account for length differences
        differences += Math.Abs(text1.Length - text2.Length)

        Return 1.0 - CDbl(differences) / maxLength
    End Function

    Private Shared Function GetDetailedDifferences(text1 As String, text2 As String) As Integer
        ' Implementation for detailed difference tracking
        Return Math.Abs(text1.Length - text2.Length)
    End Function
End Class

public static void CompareByPage(string pdf1Path, string pdf2Path)
{
    // Using Comparer class pattern for the first PDF document
    var pdf1 = PdfDocument.FromFile(pdf1Path);
    var pdf2 = PdfDocument.FromFile(pdf2Path);

    int maxPages = Math.Max(pdf1.PageCount, pdf2.PageCount);
    var pageResults = new List<PageComparisonResult>();

    for (int i = 0; i < maxPages; i++)
    {
        string page1Text = i < pdf1.PageCount ?
            pdf1.ExtractTextFromPage(i) : "";
        string page2Text = i < pdf2.PageCount ?
            pdf2.ExtractTextFromPage(i) : "";

        if (page1Text != page2Text)
        {
            Console.WriteLine($"Difference found on page {i + 1}");

            // Calculate page-specific similarity
            double pageSimilarity = CalculateSimilarity(page1Text, page2Text);
            Console.WriteLine($"  Page {i + 1} similarity: {pageSimilarity:P}");

            // Store results for reporting
            pageResults.Add(new PageComparisonResult 
            { 
                PageNumber = i + 1, 
                Similarity = pageSimilarity,
                HasDifferences = true
            });
        }
    }

    // Generate summary report
    GeneratePageReport(pageResults);
}

public class PageComparisonResult
{
    public int PageNumber { get; set; }
    public double Similarity { get; set; }
    public bool HasDifferences { get; set; }
}

Option Strict On



Public Shared Sub CompareByPage(pdf1Path As String, pdf2Path As String)
    ' Using Comparer class pattern for the first PDF document
    Dim pdf1 = PdfDocument.FromFile(pdf1Path)
    Dim pdf2 = PdfDocument.FromFile(pdf2Path)

    Dim maxPages As Integer = Math.Max(pdf1.PageCount, pdf2.PageCount)
    Dim pageResults As New List(Of PageComparisonResult)()

    For i As Integer = 0 To maxPages - 1
        Dim page1Text As String = If(i < pdf1.PageCount, pdf1.ExtractTextFromPage(i), "")
        Dim page2Text As String = If(i < pdf2.PageCount, pdf2.ExtractTextFromPage(i), "")

        If page1Text <> page2Text Then
            Console.WriteLine($"Difference found on page {i + 1}")

            ' Calculate page-specific similarity
            Dim pageSimilarity As Double = CalculateSimilarity(page1Text, page2Text)
            Console.WriteLine($"  Page {i + 1} similarity: {pageSimilarity:P}")

            ' Store results for reporting
            pageResults.Add(New PageComparisonResult With {
                .PageNumber = i + 1,
                .Similarity = pageSimilarity,
                .HasDifferences = True
            })
        End If
    Next

    ' Generate summary report
    GeneratePageReport(pageResults)
End Sub

Public Class PageComparisonResult
    Public Property PageNumber As Integer
    Public Property Similarity As Double
    Public Property HasDifferences As Boolean
End Class

public class MultiPdfComparer
{
    public static void CompareMultiple(params string[] pdfPaths)
    {
        if (pdfPaths.Length < 2) 
        {
            Console.WriteLine("At least 2 PDFs required for comparison");
            return;
        }

        // Load first PDF document as reference
        var referencePdf = PdfDocument.FromFile(pdfPaths[0]);
        string referenceText = referencePdf.ExtractAllText();

        var results = new List<ComparisonResult>();

        // Compare with other PDF files
        for (int i = 1; i < pdfPaths.Length; i++)
        {
            try
            {
                var currentPdf = PdfDocument.FromFile(pdfPaths[i]);
                string currentText = currentPdf.ExtractAllText();

                double similarity = CalculateSimilarity(referenceText, currentText);

                results.Add(new ComparisonResult
                {
                    FileName = Path.GetFileName(pdfPaths[i]),
                    Similarity = similarity,
                    IsIdentical = referenceText == currentText
                });

                if (referenceText != currentText)
                {
                    Console.WriteLine($"PDF {i} differs from reference - Similarity: {similarity:P}");
                }
                else
                {
                    Console.WriteLine($"PDF {i} is identical to reference");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error processing {pdfPaths[i]}: {ex.Message}");
            }
        }

        // Generate batch comparison report
        GenerateBatchReport(results);
    }

    private static void GenerateBatchReport(List<ComparisonResult> results)
    {
        // Implementation for batch report generation
        // Can use IronPDF's HTML to PDF feature for formatted reports
    }
}

public class ComparisonResult
{
    public string FileName { get; set; }
    public double Similarity { get; set; }
    public bool IsIdentical { get; set; }
}

Imports System
Imports System.Collections.Generic
Imports System.IO

Public Class MultiPdfComparer
    Public Shared Sub CompareMultiple(ParamArray pdfPaths As String())
        If pdfPaths.Length < 2 Then
            Console.WriteLine("At least 2 PDFs required for comparison")
            Return
        End If

        ' Load first PDF document as reference
        Dim referencePdf = PdfDocument.FromFile(pdfPaths(0))
        Dim referenceText As String = referencePdf.ExtractAllText()

        Dim results As New List(Of ComparisonResult)()

        ' Compare with other PDF files
        For i As Integer = 1 To pdfPaths.Length - 1
            Try
                Dim currentPdf = PdfDocument.FromFile(pdfPaths(i))
                Dim currentText As String = currentPdf.ExtractAllText()

                Dim similarity As Double = CalculateSimilarity(referenceText, currentText)

                results.Add(New ComparisonResult With {
                    .FileName = Path.GetFileName(pdfPaths(i)),
                    .Similarity = similarity,
                    .IsIdentical = (referenceText = currentText)
                })

                If referenceText <> currentText Then
                    Console.WriteLine($"PDF {i} differs from reference - Similarity: {similarity:P}")
                Else
                    Console.WriteLine($"PDF {i} is identical to reference")
                End If
            Catch ex As Exception
                Console.WriteLine($"Error processing {pdfPaths(i)}: {ex.Message}")
            End Try
        Next

        ' Generate batch comparison report
        GenerateBatchReport(results)
    End Sub

    Private Shared Sub GenerateBatchReport(results As List(Of ComparisonResult))
        ' Implementation for batch report generation
        ' Can use IronPDF's HTML to PDF feature for formatted reports
    End Sub
End Class

Public Class ComparisonResult
    Public Property FileName As String
    Public Property Similarity As Double
    Public Property IsIdentical As Boolean
End Class

public static void CompareSecuredPdfs(string pdf1Path, string pdf2Path,
                                      string password1, string password2)
{
    try
    {
        // Load and compare two PDFs with passwords
        // IronPDF handles various encryption types automatically
        var pdf1 = PdfDocument.FromFile(pdf1Path, password1);
        var pdf2 = PdfDocument.FromFile(pdf2Path, password2);

        // Verify successful loading
        Console.WriteLine($"PDF 1 loaded: {pdf1.PageCount} pages");
        Console.WriteLine($"PDF 2 loaded: {pdf2.PageCount} pages");

        string text1 = pdf1.ExtractAllText();
        string text2 = pdf2.ExtractAllText();

        // Compare two PDF files and save results
        bool identical = text1.Equals(text2);
        double similarity = CalculateSimilarity(text1, text2);

        var comparisonResult = identical ? "identical" : "different";
        Console.WriteLine($"Secured PDFs are {comparisonResult}");
        Console.WriteLine($"Similarity: {similarity:P}");

        // Optional: Save comparison results to a new secured PDF
        if (!identical)
        {
            SaveSecuredComparisonReport(similarity, "comparison-report.pdf", "report-password");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error handling secured PDFs: {ex.Message}");
        // Handle incorrect passwords or other security issues
    }
}

private static void SaveSecuredComparisonReport(double similarity, string outputPath, string password)
{
    // Create and secure the comparison report
    var renderer = new ChromePdfRenderer();
    var reportPdf = renderer.RenderHtmlAsPdf($"<h1>Comparison Result</h1><p>Similarity: {similarity:P}</p>");

    // Apply security settings
    reportPdf.SecuritySettings.OwnerPassword = password;
    reportPdf.SecuritySettings.UserPassword = password;
    reportPdf.SecuritySettings.AllowUserPrinting = true;
    reportPdf.SecuritySettings.AllowUserCopyPasteContent = false;

    reportPdf.SaveAs(outputPath);
}

Imports System

Public Module PdfComparer

    Public Sub CompareSecuredPdfs(pdf1Path As String, pdf2Path As String, password1 As String, password2 As String)
        Try
            ' Load and compare two PDFs with passwords
            ' IronPDF handles various encryption types automatically
            Dim pdf1 = PdfDocument.FromFile(pdf1Path, password1)
            Dim pdf2 = PdfDocument.FromFile(pdf2Path, password2)

            ' Verify successful loading
            Console.WriteLine($"PDF 1 loaded: {pdf1.PageCount} pages")
            Console.WriteLine($"PDF 2 loaded: {pdf2.PageCount} pages")

            Dim text1 As String = pdf1.ExtractAllText()
            Dim text2 As String = pdf2.ExtractAllText()

            ' Compare two PDF files and save results
            Dim identical As Boolean = text1.Equals(text2)
            Dim similarity As Double = CalculateSimilarity(text1, text2)

            Dim comparisonResult As String = If(identical, "identical", "different")
            Console.WriteLine($"Secured PDFs are {comparisonResult}")
            Console.WriteLine($"Similarity: {similarity:P}")

            ' Optional: Save comparison results to a new secured PDF
            If Not identical Then
                SaveSecuredComparisonReport(similarity, "comparison-report.pdf", "report-password")
            End If
        Catch ex As Exception
            Console.WriteLine($"Error handling secured PDFs: {ex.Message}")
            ' Handle incorrect passwords or other security issues
        End Try
    End Sub

    Private Sub SaveSecuredComparisonReport(similarity As Double, outputPath As String, password As String)
        ' Create and secure the comparison report
        Dim renderer = New ChromePdfRenderer()
        Dim reportPdf = renderer.RenderHtmlAsPdf($"<h1>Comparison Result</h1><p>Similarity: {similarity:P}</p>")

        ' Apply security settings
        reportPdf.SecuritySettings.OwnerPassword = password
        reportPdf.SecuritySettings.UserPassword = password
        reportPdf.SecuritySettings.AllowUserPrinting = True
        reportPdf.SecuritySettings.AllowUserCopyPasteContent = False

        reportPdf.SaveAs(outputPath)
    End Sub

End Module

public static void CreateComparisonReport(string pdf1Path, string pdf2Path)
{
    var pdf1 = PdfDocument.FromFile(pdf1Path);
    var pdf2 = PdfDocument.FromFile(pdf2Path);

    // Extract and compare with detailed tracking
    var differences = new List<PageDifference>();
    int totalPages = Math.Max(pdf1.PageCount, pdf2.PageCount);

    for (int i = 0; i < totalPages; i++)
    {
        // Extract page text with null checking
        string page1Text = i < pdf1.PageCount ? pdf1.ExtractTextFromPage(i) ?? string.Empty : string.Empty;
        string page2Text = i < pdf2.PageCount ? pdf2.ExtractTextFromPage(i) ?? string.Empty : string.Empty;

        // If identical, no entry needed
        if (page1Text == page2Text) continue;

        // Compute detailed similarity metrics
        double similarity = CalculateSimilarity(page1Text, page2Text);

        differences.Add(new PageDifference
        {
            PageNumber = i + 1,
            Similarity = similarity,
            Text1Length = page1Text.Length,
            Text2Length = page2Text.Length,
            CharacterDifferences = GetCharacterDifferences(page1Text, page2Text)
        });
    }

    // Create styled HTML report
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    var sb = new System.Text.StringBuilder();
    sb.Append(@"
        <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; margin: 20px; }
                h1 { color: #333; border-bottom: 2px solid #4CAF50; }
                .summary { background-color: #f0f0f0; padding: 15px; border-radius: 5px; }
                .difference { margin: 10px 0; padding: 10px; border-left: 3px solid #ff9800; }
                table { border-collapse: collapse; width: 100%; }
                th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
                th { background-color: #4CAF50; color: white; }
            </style>
        </head>
        <body>
    ");

    sb.Append("<h1>PDF Comparison Report</h1>");
    sb.Append($"<div class='summary'>");
    sb.Append($"<h2>Summary</h2>");
    sb.Append($"<p><strong>Files Compared:</strong> {Path.GetFileName(pdf1Path)} vs {Path.GetFileName(pdf2Path)}</p>");
    sb.Append($"<p><strong>Total Differences:</strong> {differences.Count} pages</p>");
    sb.Append($"<p><strong>Report Generated:</strong> {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>");
    sb.Append("</div>");

    if (differences.Count > 0)
    {
        sb.Append("<h2>Detailed Differences</h2>");
        sb.Append("<table>");
        sb.Append("<tr><th>Page</th><th>Similarity</th><th>File 1 Length</th><th>File 2 Length</th><th>Character Differences</th></tr>");

        foreach (var diff in differences)
        {
            sb.Append($"<tr>");
            sb.Append($"<td>{diff.PageNumber}</td>");
            sb.Append($"<td>{diff.Similarity:P}</td>");
            sb.Append($"<td>{diff.Text1Length}</td>");
            sb.Append($"<td>{diff.Text2Length}</td>");
            sb.Append($"<td>{diff.CharacterDifferences}</td>");
            sb.Append($"</tr>");
        }

        sb.Append("</table>");
    }
    else
    {
        sb.Append("<p class='summary' style='background-color: #c8e6c9;'>✓ No differences detected - files are identical.</p>");
    }

    sb.Append("</body></html>");

    var reportPdf = renderer.RenderHtmlAsPdf(sb.ToString());

    // Add metadata to the report
    reportPdf.MetaData.Author = "PDF Comparison Tool";
    reportPdf.MetaData.Title = "PDF Comparison Report";
    reportPdf.MetaData.CreationDate = DateTime.Now;

    reportPdf.SaveAs("comparison-report.pdf");
}

public class PageDifference
{
    public int PageNumber { get; set; }
    public double Similarity { get; set; }
    public int Text1Length { get; set; }
    public int Text2Length { get; set; }
    public int CharacterDifferences { get; set; }
}

private static int GetCharacterDifferences(string text1, string text2)
{
    // Implementation for counting character-level differences
    // Could use more sophisticated algorithms like Levenshtein distance
    return Math.Abs(text1.Length - text2.Length);
}

Imports System
Imports System.IO
Imports System.Text
Imports IronPdf

Public Module PdfComparison

    Public Sub CreateComparisonReport(pdf1Path As String, pdf2Path As String)
        Dim pdf1 = PdfDocument.FromFile(pdf1Path)
        Dim pdf2 = PdfDocument.FromFile(pdf2Path)

        ' Extract and compare with detailed tracking
        Dim differences As New List(Of PageDifference)()
        Dim totalPages As Integer = Math.Max(pdf1.PageCount, pdf2.PageCount)

        For i As Integer = 0 To totalPages - 1
            ' Extract page text with null checking
            Dim page1Text As String = If(i < pdf1.PageCount, pdf1.ExtractTextFromPage(i), String.Empty)
            Dim page2Text As String = If(i < pdf2.PageCount, pdf2.ExtractTextFromPage(i), String.Empty)

            ' If identical, no entry needed
            If page1Text = page2Text Then Continue For

            ' Compute detailed similarity metrics
            Dim similarity As Double = CalculateSimilarity(page1Text, page2Text)

            differences.Add(New PageDifference With {
                .PageNumber = i + 1,
                .Similarity = similarity,
                .Text1Length = page1Text.Length,
                .Text2Length = page2Text.Length,
                .CharacterDifferences = GetCharacterDifferences(page1Text, page2Text)
            })
        Next

        ' Create styled HTML report
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

        Dim sb As New StringBuilder()
        sb.Append("
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; margin: 20px; }
                    h1 { color: #333; border-bottom: 2px solid #4CAF50; }
                    .summary { background-color: #f0f0f0; padding: 15px; border-radius: 5px; }
                    .difference { margin: 10px 0; padding: 10px; border-left: 3px solid #ff9800; }
                    table { border-collapse: collapse; width: 100%; }
                    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
                    th { background-color: #4CAF50; color: white; }
                </style>
            </head>
            <body>
        ")

        sb.Append("<h1>PDF Comparison Report</h1>")
        sb.Append("<div class='summary'>")
        sb.Append("<h2>Summary</h2>")
        sb.Append($"<p><strong>Files Compared:</strong> {Path.GetFileName(pdf1Path)} vs {Path.GetFileName(pdf2Path)}</p>")
        sb.Append($"<p><strong>Total Differences:</strong> {differences.Count} pages</p>")
        sb.Append($"<p><strong>Report Generated:</strong> {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>")
        sb.Append("</div>")

        If differences.Count > 0 Then
            sb.Append("<h2>Detailed Differences</h2>")
            sb.Append("<table>")
            sb.Append("<tr><th>Page</th><th>Similarity</th><th>File 1 Length</th><th>File 2 Length</th><th>Character Differences</th></tr>")

            For Each diff In differences
                sb.Append("<tr>")
                sb.Append($"<td>{diff.PageNumber}</td>")
                sb.Append($"<td>{diff.Similarity:P}</td>")
                sb.Append($"<td>{diff.Text1Length}</td>")
                sb.Append($"<td>{diff.Text2Length}</td>")
                sb.Append($"<td>{diff.CharacterDifferences}</td>")
                sb.Append("</tr>")
            Next

            sb.Append("</table>")
        Else
            sb.Append("<p class='summary' style='background-color: #c8e6c9;'>✓ No differences detected - files are identical.</p>")
        End If

        sb.Append("</body></html>")

        Dim reportPdf = renderer.RenderHtmlAsPdf(sb.ToString())

        ' Add metadata to the report
        reportPdf.MetaData.Author = "PDF Comparison Tool"
        reportPdf.MetaData.Title = "PDF Comparison Report"
        reportPdf.MetaData.CreationDate = DateTime.Now

        reportPdf.SaveAs("comparison-report.pdf")
    End Sub

    Private Function GetCharacterDifferences(text1 As String, text2 As String) As Integer
        ' Implementation for counting character-level differences
        ' Could use more sophisticated algorithms like Levenshtein distance
        Return Math.Abs(text1.Length - text2.Length)
    End Function

End Module

Public Class PageDifference
    Public Property PageNumber As Integer
    Public Property Similarity As Double
    Public Property Text1Length As Integer
    Public Property Text2Length As Integer
    Public Property CharacterDifferences As Integer
End Class