Cómo comparar dos archivos PDF en C#

Prerequisites and Setup

Before starting, ensure you have installed:

• Visual Studio 2019 or later
• .NET Framework 4.6.2+ or .NET Core 3.1+
• Basic C# knowledge

Comparación básica de documentos PDF

Empecemos con un código de ejemplo para comparar archivos PDF extrayendo y comparando su contenido textual:

using IronPdf;csharp public class BasicPdfComparer { public static bool ComparePdfFiles(string firstPdfPath, string secondPdfPath) { // Load two PDF documents var pdf1 = PdfDocument.FromFile(firstPdfPath); var pdf2 = PdfDocument.FromFile(secondPdfPath);

    // Extract all text from both PDFs
    string text1 = pdf1.ExtractAllText();
    string text2 = pdf2.ExtractAllText();

    // Compare the two documents
    bool areIdentical = text1 == text2;

    // Find differences and calculate similarity
    double similarity = CalculateSimilarity(text1, text2);
    Console.WriteLine($"Documents are {(areIdentical ? "identical" : "different")}");
    Console.WriteLine($"Similarity: {similarity:F2}%");

    return areIdentical;
}

private static double CalculateSimilarity(string text1, string text2)
{
    if (text1 == text2) return 100.0;
    if (string.IsNullOrEmpty(text1) || string.IsNullOrEmpty(text2)) return 0.0;

    int matchingChars = 0;
    int minLength = Math.Min(text1.Length, text2.Length);
    for (int i = 0; i < minLength; i++)
    {
        if (text1[i] == text2[i]) matchingChars++;
    }

    return (double)matchingChars / Math.Max(text1.Length, text2.Length) * 100;
}

} using IronPdf;

Este código carga dos archivos PDF utilizando el método PdfDocument.FromFile() de IronPDF, extrae todo el contenido de texto y realiza una comparación directa de cadenas. El método de comparación proporciona métricas para identificar el grado de coincidencia de los documentos.

Método de comparación página por página

Para un análisis más detallado, compare dos PDF página por página para identificar exactamente dónde se producen las diferencias:

using IronPdf;csharp public static void ComparePageByPage(string firstPdfPath, string secondPdfPath) { // Load two files var pdf1 = PdfDocument.FromFile(firstPdfPath); var pdf2 = PdfDocument.FromFile(secondPdfPath);

int maxPages = Math.Max(pdf1.PageCount, pdf2.PageCount);
int differencesFound = 0;

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

    if (page1Text != page2Text)
    {
        differencesFound++;
        Console.WriteLine($"Page {i + 1}: Differences detected");
    }
    else
    {
        Console.WriteLine($"Page {i + 1}: Identical");
    }
}
Console.WriteLine($"\nSummary: {differencesFound} page(s) with changes");

} using IronPdf;

El método ExtractTextFromPage() permite la extracción específica de páginas concretas. Este enfoque ayuda a los desarrolladores a identificar las discrepancias entre las distintas versiones de los documentos PDF.

Utilización del patrón de clase Comparer

Cree una clase de comparador dedicada para mejorar su funcionalidad de comparación:

using IronPdf;csharp public class PdfComparer { private PdfDocument pdf1; private PdfDocument pdf2; private bool disposed;

public PdfComparer(string file1Path, string file2Path)
{
    // Load the two PDFs
    pdf1 = PdfDocument.FromFile(file1Path);
    pdf2 = PdfDocument.FromFile(file2Path);
}

public ComparisonResult Compare()
{
    var result = new ComparisonResult();

    // Compare PDF documents
    string text1 = pdf1?.ExtractAllText() ?? string.Empty;
    string text2 = pdf2?.ExtractAllText() ?? string.Empty;

    result.AreIdentical = string.Equals(text1, text2, StringComparison.Ordinal);
    result.SimilarityPercent = CalculateSimilarity(text1, text2);
    result.Differences = FindDifferences(text1, text2);

    return result;
}

private List<string> FindDifferences(string text1, string text2)
{
    var differences = new List<string>();

    // Normalise nulls
    text1 ??= string.Empty;
    text2 ??= string.Empty;

    if (string.Equals(text1, text2, StringComparison.Ordinal))
        return differences;

    // Page-aware comparisons aren't possible here because we only have full-text;
    // produce a concise, actionable difference entry:
    int min = Math.Min(text1.Length, text2.Length);
    int firstDiff = -1;
    for (int i = 0; i < min; i++)
    {
        if (text1[i] != text2[i])
        {
            firstDiff = i;
            break;
        }
    }

    if (firstDiff == -1 && text1.Length != text2.Length)
    {
        // No differing character in the overlap, but lengths differ
        firstDiff = min;
    }

    // Create short excerpts around the first difference for context
    int excerptLength = 200;
    string excerpt1 = string.Empty;
    string excerpt2 = string.Empty;

    if (firstDiff >= 0)
    {
        int start1 = Math.Max(0, firstDiff);
        int len1 = Math.Min(excerptLength, Math.Max(0, text1.Length - start1));
        excerpt1 = start1 < text1.Length ? text1.Substring(start1, len1) : string.Empty;

        int start2 = Math.Max(0, firstDiff);
        int len2 = Math.Min(excerptLength, Math.Max(0, text2.Length - start2));
        excerpt2 = start2 < text2.Length ? text2.Substring(start2, len2) : string.Empty;
    }

    // HTML-encode excerpts if they will be embedded into HTML reports
    string safeExcerpt1 = System.Net.WebUtility.HtmlEncode(excerpt1);
    string safeExcerpt2 = System.Net.WebUtility.HtmlEncode(excerpt2);
    double similarity = CalculateSimilarity(text1, text2);

    differences.Add($"Similarity: {similarity:F2}%. Lengths: [{text1.Length}, {text2.Length}]. First difference index: {firstDiff}. Excerpt1: \"{safeExcerpt1}\" Excerpt2: \"{safeExcerpt2}\"");

    return differences;
}

public void Close()
{
    Dispose();
}

public void Dispose()
{
    if (disposed) return;
    disposed = true;
    pdf1?.Dispose();
    pdf2?.Dispose();
}

}

public class ComparisonResult { // True when extracted text is exactly the same public bool AreIdentical { get; set; }

// Similarity expressed as percent (0..100)
public double SimilarityPercent { get; set; }

// Human readable difference entries
public List<string> Differences { get; set; } = new List<string>();

} using IronPdf;

Esta estructura de clases proporciona una forma limpia de comparar documentos PDF, a la vez que gestiona adecuadamente los objetos y las referencias de los documentos.

Creación de un informe de comparación visual

Genera un informe basado en HTML que resalte las diferencias entre dos documentos y guárdalo como archivo PDF:

using IronPdf;csharp public static void CreateComparisonReport(string pdf1Path, string pdf2Path, string outputPath) { // Load PDFs for comparison var pdf1 = PdfDocument.FromFile(pdf1Path); var pdf2 = PdfDocument.FromFile(pdf2Path);

// Build HTML report with details
string htmlReport = @"
    <html>
    <head>
        <style>
            body { font-family: Arial, sans-serif; margin: 20px; }
            .identical { color: green; }
            .different { color: red; }
            table { width: 100%; border-collapse: collapse; }
            th, td { border: 1px solid #ddd; padding: 8px; }
        </style>
    </head>
    <body>
        <h1>PDF Comparison Report</h1>
        <table>
            <tr><th>Page</th><th>Status</th></tr>";

// Process each page
for (int i = 0; i < Math.Max(pdf1.PageCount, pdf2.PageCount); i++)
{
    string page1 = i < pdf1.PageCount ? pdf1.ExtractTextFromPage(i) : "";
    string page2 = i < pdf2.PageCount ? pdf2.ExtractTextFromPage(i) : "";

    bool identical = page1 == page2;
    string status = identical ? "Identical" : "Different";
    htmlReport += $"<tr><td>Page {i + 1}</td><td class='{status.ToLower()}'>{status}</td></tr>";
}

htmlReport += "</table></body></html>";

// Create and save the report
var renderer = new ChromePdfRenderer();
var reportPdf = renderer.RenderHtmlAsPdf(htmlReport);
reportPdf.SaveAs(outputPath);
Console.WriteLine($"Report saved to: {outputPath}");

} using IronPdf;

Este código muestra cómo crear un documento PDF profesional con resultados de comparación. El informe se guarda en la ruta especificada.

Comparación de varios documentos PDF

Cuando necesite comparar varios documentos PDF simultáneamente, utilice este método:

using IronPdf;csharp public static void CompareMultiplePdfs(params string[] pdfPaths) { if (pdfPaths.Length < 2) { Console.WriteLine("Need at least two files to compare"); return; }

// Load multiple PDF documents
var pdfs = new List<PdfDocument>();
foreach (var path in pdfPaths)
{
    pdfs.Add(PdfDocument.FromFile(path));
}

// Compare all documents
for (int i = 0; i < pdfs.Count - 1; i++)
{
    for (int j = i + 1; j < pdfs.Count; j++)
    {
        string text1 = pdfs[i].ExtractAllText();
        string text2 = pdfs[j].ExtractAllText();
        bool identical = text1 == text2;
        Console.WriteLine($"File {i + 1} vs File {j + 1}: {(identical ? "Identical" : "Different")}");
    }
}

// Close all documents
pdfs.ForEach(pdf => pdf.Dispose());

} using IronPdf;

Este enfoque permite comparar varios documentos PDF en una sola ejecución, lo que resulta útil para los requisitos de procesamiento por lotes.

Control de versiones de contratos en el mundo real

He aquí un ejemplo práctico de seguimiento de revisiones en documentos jurídicos:

using IronPdf;csharp public class ContractVersionControl { public static void CompareContractVersions(string originalPath, string revisedPath) { // System for comparing contract versions Console.WriteLine("Contract Version Comparison System");

    var original = PdfDocument.FromFile(originalPath);
    var revised = PdfDocument.FromFile(revisedPath);

    // Extract contract contents
    string originalText = original.ExtractAllText();
    string revisedText = revised.ExtractAllText();

    if (originalText == revisedText)
    {
        Console.WriteLine("No changes detected");
    }
    else
    {
        Console.WriteLine("Changes detected in revised version");

        // Create detailed report
        string reportPath = $"contract_comparison_{DateTime.Now:yyyyMMdd}.pdf";
        CreateComparisonReport(originalPath, revisedPath, reportPath);
        Console.WriteLine($"Report created: {reportPath}");
    }

    // Close documents
    original.Dispose();
    revised.Dispose();
}

} using IronPdf;

Esto demuestra cómo comparar dos versiones de contratos PDF y generar informes para su revisión. El sistema detecta automáticamente los cambios y crea la documentación.

Manejo de archivos PDF protegidos con contraseña

IronPDF gestiona sin problemas archivos PDF cifrados pasando la contraseña al llamar al método de carga:

using IronPdf;csharp public static bool CompareProtectedPdfs(string pdf1Path, string pass1, string pdf2Path, string pass2) { // Load password-protected two PDFs var pdf1 = PdfDocument.FromFile(pdf1Path, pass1); var pdf2 = PdfDocument.FromFile(pdf2Path, pass2);

// Extract and compare text
string text1 = pdf1.ExtractAllText();
string text2 = pdf2.ExtractAllText();

bool result = text1 == text2;

// Close and dispose
pdf1.Dispose();
pdf2.Dispose();

return result;

} using IronPdf;

Basta con pasar el parámetro de la contraseña al cargar PDF protegidos. IronPDF gestiona el descifrado automáticamente.

Instrucciones paso a paso

Siga estos pasos para implementar la comparación de PDF en su proyecto .NET:

1. Instale el paquete IronPDF .NET a través de NuGet.
2. Añada la referencia al espacio de nombres IronPDF.
3. Cree una instancia de PdfDocument para cada archivo.
4. Utilice métodos como ExtractAllText() para obtener el contenido.
5. Compare el texto extraído o implemente una lógica personalizada.
6. Guarde los resultados o genere informes según sea necesario.
7. Cerrar documento objetos a recursos libres.

Configuración de la licencia

Para utilizar IronPDF sin marcas de agua, configure su clave de licencia:

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

Visite la página de licencias y configure archivos PDF con capacidades de comparación de nivel profesional.

Mejores prácticas

1. Acepte todas las revisiones antes de la comparación si trabaja con cambios rastreados.
2. Desarrollar la gestión de errores para operaciones de archivo cruciales.
3. Mejorar el rendimiento mediante la creación de comparaciones específicas de páginas para documentos de gran tamaño.
4. Ejecute comparaciones de forma asíncrona para varios documentos PDF.
5. Actualice su biblioteca con regularidad para obtener las últimas funciones y asistencia.

Conclusión

IronPDF simplifica el proceso de comparación de dos archivos PDF utilizando C# con su intuitiva API y sus potentes funciones de extracción. Desde la comparación básica hasta la creación de informes detallados, IronPDF proporciona todas las herramientas necesarias para flujos de trabajo sólidos de comparación de documentos.

La combinación de instalación sencilla, funcionalidad completa y compatibilidad multiplataforma convierte a IronPDF en la opción ideal para los desarrolladores que implementan la comparación de PDF en aplicaciones .NET. Tanto si está desarrollando sistemas de gestión de documentos como soluciones de control de versiones, el enfoque directo de IronPDF le permitirá ponerse en marcha rápidamente.

Comience su prueba gratuita de IronPDF hoy mismo e implemente funciones profesionales de comparación de PDF. Con un soporte técnico completo y una amplia documentación, dispondrá de una funcionalidad lista para producción en cuestión de horas. Consulte la documentación completa para obtener más información sobre las funciones avanzadas. using IronPdf;