Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Comparer deux fichiers PDF à l'aide de C#
UTILISATION DE IRONPDF

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

Curtis Chau
Curtis Chau
Publié:

Introduction

Comparer des documents PDF de manière programmatique est une exigence cruciale dans les applications .NET Core modernes, qu'il s'agisse de suivre les révisions de documents ou d'assurer la conformité dans les flux de travail juridiques. Qu'il s'agisse de valider des modifications contractuelles, de contrôler différentes versions ou de mettre en œuvre des processus d'assurance qualité, la comparaison automatisée de fichiers PDF permet aux développeurs de gagner du temps et de réduire les divergences.

IronPDF propose une approche rationalisée pour comparer deux fichiers PDF à l'aide de C# en combinant de puissantes capacités d'extraction de texte avec des options flexibles de comparaison de documents. Ce tutoriel montre comment comparer efficacement deux documents PDF à l'aide de l'API intuitive d'IronPDF, avec des exemples de code pratiques.

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 1 - IronPDF

Pour commencer : Installer et configurer votre projet .NET

Commencez par installer IronPDF via le gestionnaire de paquets NuGet dans votre projet .NET :

Install-Package IronPdf
Install-Package IronPdf
SHELL

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 2 - Installation

Ou ajoutez la référence à l'aide du CLI .NET :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Pour les environnements Linux ou Windows, se référer à la documentation pour les instructions spécifiques à la plateforme. Une fois le paquet .NET installé, configurez votre licence (optionnelle pour le développement) :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 3 - Caractéristiques

Comparaison de base : Comparer deux PDF

La comparaison de documents PDF repose sur l'extraction et la comparaison du contenu textuel. Voici un exemple de code pour comparer deux fichiers PDF :

using IronPdf;
using System;

class PdfComparer
{
    public static void CompareSimple(string pdf1Path, string pdf2Path)
    {
        // Load two PDF documents
        var pdf1 = PdfDocument.FromFile(pdf1Path);
        var pdf2 = PdfDocument.FromFile(pdf2Path);
        // Extract text from both PDFs
        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");
        }
    }

    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);
        for (int i = 0; i < minLength; i++)
        {
            if (text1[i] != text2[i]) differences++;
        }
        differences += Math.Abs(text1.Length - text2.Length);
        return 1.0 - (double)differences / maxLength;
    }
}
using IronPdf;
using System;

class PdfComparer
{
    public static void CompareSimple(string pdf1Path, string pdf2Path)
    {
        // Load two PDF documents
        var pdf1 = PdfDocument.FromFile(pdf1Path);
        var pdf2 = PdfDocument.FromFile(pdf2Path);
        // Extract text from both PDFs
        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");
        }
    }

    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);
        for (int i = 0; i < minLength; i++)
        {
            if (text1[i] != text2[i]) differences++;
        }
        differences += Math.Abs(text1.Length - text2.Length);
        return 1.0 - (double)differences / maxLength;
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ce code charge deux fichiers PDF, extrait leur contenu textuel complet et effectue une comparaison de base. La méthode fournit un résultat indiquant le degré de similitude des documents, ce qui permet de quantifier les différences entre les fichiers.

Entrée

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 4 - Exemple d'entrée PDF 1

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 5 - Exemple d'entrée PDF 2

Sortie

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 6 - Sortie de la console

Avancé : Comparaison PDF page par page

Pour une analyse plus détaillée, comparez les documents PDF page par page afin d'identifier précisément les changements :

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);
    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}");
            // Highlight differences in output
        }
    }
}
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);
    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}");
            // Highlight differences in output
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Cette méthode de comparaison itère sur chaque page, en comparant le contenu individuellement. Le processus traite les PDF avec différents nombres de pages de manière gracieuse, ce qui le rend idéal pour comparer plusieurs documents PDF dont les pages ont pu être mises à jour.

Comparer plusieurs documents PDF

Pour améliorer votre système de comparaison de plusieurs documents PDF, étendez la classe Comparer :

public class MultiPdfComparer
{
    public static void CompareMultiple(params string[] pdfPaths)
    {
        if (pdfPaths.Length < 2) return;
        // Load first PDF document as reference
        var referencePdf = PdfDocument.FromFile(pdfPaths[0]);
        string referenceText = referencePdf.ExtractAllText();
        // Compare with other PDF files
        for (int i = 1; i < pdfPaths.Length; i++)
        {
            var currentPdf = PdfDocument.FromFile(pdfPaths[i]);
            string currentText = currentPdf.ExtractAllText();
            if (referenceText != currentText)
            {
                Console.WriteLine($"PDF {i} differs from reference");
            }
        }
        // Results saved for further processing
    }
}
public class MultiPdfComparer
{
    public static void CompareMultiple(params string[] pdfPaths)
    {
        if (pdfPaths.Length < 2) return;
        // Load first PDF document as reference
        var referencePdf = PdfDocument.FromFile(pdfPaths[0]);
        string referenceText = referencePdf.ExtractAllText();
        // Compare with other PDF files
        for (int i = 1; i < pdfPaths.Length; i++)
        {
            var currentPdf = PdfDocument.FromFile(pdfPaths[i]);
            string currentText = currentPdf.ExtractAllText();
            if (referenceText != currentText)
            {
                Console.WriteLine($"PDF {i} differs from reference");
            }
        }
        // Results saved for further processing
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Cette approche permet aux développeurs de comparer plusieurs documents PDF à un document de référence, ce qui est parfait pour les besoins de traitement par lots.

Sortie

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 7 - Comparer plusieurs PDF

Travailler avec des PDF protégés par mot de passe

IronPDF traite de manière transparente les documents PDF cryptés en suivant des étapes simples. Transmettre les mots de passe lors du chargement de fichiers protégés :

public static void CompareSecuredPdfs(string pdf1Path, string pdf2Path,
                                      string password1, string password2)
{
    // Load and compare two PDFs with passwords
    var pdf1 = PdfDocument.FromFile(pdf1Path, password1);
    var pdf2 = PdfDocument.FromFile(pdf2Path, password2);
    string text1 = pdf1.ExtractAllText();
    string text2 = pdf2.ExtractAllText();
    // Compare two PDF files and save results
    bool identical = text1.Equals(text2);
    var comparisonResult = identical ? "identical" : "different";
    Console.WriteLine($"Secured PDFs are {comparisonResult}");
    // Accept or reject changes based on comparison
}
public static void CompareSecuredPdfs(string pdf1Path, string pdf2Path,
                                      string password1, string password2)
{
    // Load and compare two PDFs with passwords
    var pdf1 = PdfDocument.FromFile(pdf1Path, password1);
    var pdf2 = PdfDocument.FromFile(pdf2Path, password2);
    string text1 = pdf1.ExtractAllText();
    string text2 = pdf2.ExtractAllText();
    // Compare two PDF files and save results
    bool identical = text1.Equals(text2);
    var comparisonResult = identical ? "identical" : "different";
    Console.WriteLine($"Secured PDFs are {comparisonResult}");
    // Accept or reject changes based on comparison
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

En transmettant des mots de passe lors de l'appel de la méthode FromFile, vous pouvez comparer deux fichiers PDF cryptés, ce qui est parfait pour les flux de documents sensibles.

Création de rapports de comparaison

Générez des résultats de comparaison détaillés et sauvegardez-les pour examen :

public static void CreateComparisonReport(string pdf1Path, string pdf2Path)
{
    var pdf1 = PdfDocument.FromFile(pdf1Path);
    var pdf2 = PdfDocument.FromFile(pdf2Path);
    // Extract and compare
    var differences = new List<string>();
    for (int i = 0; i < Math.Max(pdf1.PageCount, pdf2.PageCount); i++)
    {
        // Extract page text (guard for missing pages)
        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 a simple similarity score (0..1)
        double similarity = CalculateSimilarity(page1Text, page2Text);
        differences.Add($"Page {i + 1}: Similarity {similarity:P}. Lengths: [{page1Text.Length}, {page2Text.Length}].");
    }
    // Create output report
    var renderer = new ChromePdfRenderer();
    var sb = new System.Text.StringBuilder();
    sb.Append("<h1>PDF Comparison Results</h1>");
    sb.Append("<p>Total differences: {differences.Count}</p>");
    if (differences.Count > 0)
    {
        sb.Append("<ol>");
        foreach (var d in differences)
        {
            sb.Append($"<li><pre style='white-space:pre-wrap'>{d}</pre></li>");
        }
        sb.Append("</ol>");
    }
    else
    {
        sb.Append("<p>No page-level differences detected.</p>");
    }
    var reportHtml = sb.ToString();
    var reportPdf = renderer.RenderHtmlAsPdf(reportHtml);
    reportPdf.SaveAs("comparison-report.pdf");
}
public static void CreateComparisonReport(string pdf1Path, string pdf2Path)
{
    var pdf1 = PdfDocument.FromFile(pdf1Path);
    var pdf2 = PdfDocument.FromFile(pdf2Path);
    // Extract and compare
    var differences = new List<string>();
    for (int i = 0; i < Math.Max(pdf1.PageCount, pdf2.PageCount); i++)
    {
        // Extract page text (guard for missing pages)
        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 a simple similarity score (0..1)
        double similarity = CalculateSimilarity(page1Text, page2Text);
        differences.Add($"Page {i + 1}: Similarity {similarity:P}. Lengths: [{page1Text.Length}, {page2Text.Length}].");
    }
    // Create output report
    var renderer = new ChromePdfRenderer();
    var sb = new System.Text.StringBuilder();
    sb.Append("<h1>PDF Comparison Results</h1>");
    sb.Append("<p>Total differences: {differences.Count}</p>");
    if (differences.Count > 0)
    {
        sb.Append("<ol>");
        foreach (var d in differences)
        {
            sb.Append($"<li><pre style='white-space:pre-wrap'>{d}</pre></li>");
        }
        sb.Append("</ol>");
    }
    else
    {
        sb.Append("<p>No page-level differences detected.</p>");
    }
    var reportHtml = sb.ToString();
    var reportPdf = renderer.RenderHtmlAsPdf(reportHtml);
    reportPdf.SaveAs("comparison-report.pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Sortie

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 8 - Sortie du rapport de comparaison

Pourquoi choisir IronPDF

IronPDF excelle dans la comparaison de PDF grâce à son API simple. La bibliothèque prend en charge .NET Core, .NET Framework, et fonctionne sous Windows, Linux et macOS. Les principaux avantages incluent :

  • API simple pour comparer des fichiers PDF
  • Prise en charge de différentes versions de PDF
  • Gestion intégrée des révisions
  • Outils de comparaison faciles à développer et à créer
  • Documentation et assistance complètes

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 9 - Compatibilité multiplateforme

Conclusion

IronPDF transforme les tâches complexes de comparaison de documents PDF en opérations gérables. Qu'il s'agisse de créer des systèmes de gestion de documents ou de comparer deux fichiers PDF à l'aide de C#, IronPDF fournit tous les outils nécessaires.

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 10 - Comparer deux fichiers PDF en utilisant C# - IronPDF

Vous souhaitez en savoir plus ? Téléchargez la version d'essai gratuite d'IronPDF et configurez vos fichiers PDF en utilisant des fonctionnalités de comparaison de qualité professionnelle. Pour un déploiement en production, découvrez nos options de licensing et consultez notre documentation complète pour plus de détails.

Comment comparer efficacement deux fichiers PDF en utilisant C# avec IronPDF : Image 11 - Licence

Questions Fréquemment Posées

Comment comparer deux fichiers PDF à l'aide de C# ?

Vous pouvez comparer deux fichiers PDF à l'aide de C# en utilisant la puissante fonction de comparaison de PDF d'IronPDF, qui vous permet d'identifier les différences de texte, d'images et de mise en page entre deux documents PDF.

Quels sont les avantages de l'utilisation d'IronPDF pour la comparaison de PDF ?

IronPDF offre un moyen simple et efficace de comparer des fichiers PDF, en garantissant la précision de la détection des différences. Il prend en charge différents modes de comparaison et s'intègre parfaitement aux projets C#.

IronPDF peut-il gérer de gros fichiers PDF pour la comparaison ?

Oui, IronPDF est conçu pour traiter efficacement les fichiers PDF volumineux, ce qui le rend adapté à la comparaison de documents étendus sans compromettre les performances.

IronPDF prend-il en charge la comparaison visuelle des PDF ?

IronPDF permet de comparer visuellement les PDF en mettant en évidence les différences de mise en page et d'images, offrant ainsi une vue d'ensemble des changements entre les documents.

Est-il possible d'automatiser la comparaison de PDF avec IronPDF ?

Oui, vous pouvez automatiser les processus de comparaison de PDF à l'aide d'IronPDF dans vos applications C#, ce qui est idéal pour les scénarios nécessitant des comparaisons fréquentes ou par lots.

Quels types de différences IronPDF peut-il détecter dans les fichiers PDF ?

IronPDF peut détecter les différences textuelles, graphiques et de mise en page, garantissant ainsi une comparaison approfondie de l'ensemble du contenu des fichiers PDF.

Comment IronPDF assure-t-il la précision de la comparaison des PDF ?

IronPDF garantit la précision en utilisant des algorithmes avancés pour comparer méticuleusement le contenu des PDF, minimisant ainsi le risque de négliger des différences subtiles.

Puis-je intégrer IronPDF à d'autres applications .NET pour la comparaison de PDF ?

Oui, IronPDF est conçu pour s'intégrer de manière transparente aux applications .NET, ce qui permet aux développeurs d'incorporer la fonctionnalité de comparaison de PDF dans leurs solutions logicielles existantes.

Dois-je avoir une expérience préalable de la comparaison de PDF pour utiliser IronPDF ?

Aucune expérience préalable n'est nécessaire. IronPDF fournit des outils conviviaux et une documentation complète pour vous guider dans le processus de comparaison des PDF, même si vous êtes novice en matière de manipulation des PDF.

Existe-t-il une démo ou une version d'essai de la fonction de comparaison de PDF d'IronPDF ?

Oui, IronPDF propose un essai gratuit qui vous permet d'explorer et de tester ses fonctionnalités de comparaison de PDF avant de vous engager dans un achat.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit