excel comparison on Document Processing REST APIs | GroupDocs Cloud

Comparar archivos de Excel mediante REST en C#

Fri, 09 Oct 2026 14:45:06 +0000

Comparar hojas de cálculo de Excel de forma programática es un requisito frecuente cuando necesitas detectar cambios en los datos, auditar revisiones o generar informes. GroupDocs.Comparison Cloud SDK for .NET proporciona una potente biblioteca basada en REST que facilita la comparación de archivos Excel a través de REST en C#. Esta guía te guía a través de la carga de archivos, la configuración de opciones de comparación, la ejecución de la comparación y la obtención del resultado, con ejemplos de código en C# y cURL.

Comparar archivos Excel mediante REST en C# en 5 pasos

Cargar el archivo XLSX de origen: Utilice el método StorageApi.UploadFile para colocar sample1.xlsx en el almacenamiento en la nube.

using (var stream1 = new FileStream(localFilePath1, FileMode.Open, FileAccess.Read))
{
    var uploadRequest1 = new UploadFileRequest(remoteFilePath1, stream1);
    storageApi.UploadFile(uploadRequest1);
}

Cargar el archivo XLSX de destino: Repita la carga para sample2.xlsx.

using (var stream2 = new FileStream(localFilePath2, FileMode.Open, FileAccess.Read))
{
    var uploadRequest2 = new UploadFileRequest(remoteFilePath2, stream2);
    storageApi.UploadFile(uploadRequest2);
}

Configurar opciones de comparación: Cree un objeto CompareOptions, establezca las rutas de archivo de origen y destino, defina la ruta de salida y ajuste configuraciones como GenerateSummaryPage.

var compareOptions = new CompareOptions
{
    SourceFile = new FileInfo { FilePath = remoteFilePath1 },
    TargetFiles = new List
    {
        new FileInfo { FilePath = remoteFilePath2 }
    },
    OutputPath = remoteResultPath,
    Settings = new Settings
    {
        GenerateSummaryPage = true,
        ShowDeletedContent = true,
        ShowInsertedContent = true
    }
};

Consulte la referencia completa de la API para CompareOptions y Settings en la Referencia de API.
4. Ejecutar la comparación: Llame a CompareApi.CompareDocument con un CompareDocumentRequest.

var compareRequest = new CompareDocumentRequest(compareOptions);
var compareResult = compareApi.CompareDocument(compareRequest);

Descargar el resultado y limpiar: Recupere el result.xlsx generado, guárdelo localmente y, opcionalmente, elimine los archivos remotos.

var downloadRequest = new DownloadFileRequest(compareResult.Path);
using (var resultStream = storageApi.DownloadFile(downloadRequest))
using (var fileStream = new FileStream(localResultPath, FileMode.Create, FileAccess.Write))
{
    resultStream.CopyTo(fileStream);
}

// Clean up
storageApi.DeleteFile(new DeleteFileRequest(remoteFilePath1));
storageApi.DeleteFile(new DeleteFileRequest(remoteFilePath2));
storageApi.DeleteFile(new DeleteFileRequest(remoteResultPath));

Ejemplo de código completo: Comparar archivos Excel mediante REST en C# usando GroupDocs.Comparison

Este ejemplo muestra cómo cargar dos archivos XLSX, compararlos y descargar el resultado resaltado.

using System;
using System.Collections.Generic;
using System.IO;
using GroupDocs.Comparison.Cloud.Sdk.Api;
using GroupDocs.Comparison.Cloud.Sdk.Client;
using GroupDocs.Comparison.Cloud.Sdk.Model;
using GroupDocs.Comparison.Cloud.Sdk.Model.Requests;

namespace CompareExcelFilesExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Configuration – replace with your actual credentials
            var config = new Configuration
            {
                ClientId = "YOUR_CLIENT_ID",
                ClientSecret = "YOUR_CLIENT_SECRET"
            };

// APIs
            var compareApi = new CompareApi(config);
            var storageApi = new StorageApi(config);

// Local and remote file names
            string localFilePath1 = "sample1.xlsx";
            string localFilePath2 = "sample2.xlsx";
            string remoteFilePath1 = "sample1.xlsx";
            string remoteFilePath2 = "sample2.xlsx";
            string remoteResultPath = "result.xlsx";
            string localResultPath = "result.xlsx";

// Upload first Excel file
            using (var stream1 = new FileStream(localFilePath1, FileMode.Open, FileAccess.Read))
            {
                var uploadRequest1 = new UploadFileRequest(remoteFilePath1, stream1);
                storageApi.UploadFile(uploadRequest1);
            }

// Upload second Excel file
            using (var stream2 = new FileStream(localFilePath2, FileMode.Open, FileAccess.Read))
            {
                var uploadRequest2 = new UploadFileRequest(remoteFilePath2, stream2);
                storageApi.UploadFile(uploadRequest2);
            }

// Prepare comparison options
            var compareOptions = new CompareOptions
            {
                SourceFile = new FileInfo { FilePath = remoteFilePath1 },
                TargetFiles = new List
                {
                    new FileInfo { FilePath = remoteFilePath2 }
                },
                OutputPath = remoteResultPath,
                Settings = new Settings
                {
                    // Example: show changes in a new sheet
                    GenerateSummaryPage = true,
                    ShowDeletedContent = true,
                    ShowInsertedContent = true
                }
            };

// Execute comparison
            var compareRequest = new CompareDocumentRequest(compareOptions);
            var compareResult = compareApi.CompareDocument(compareRequest);

// Download the result file
            var downloadRequest = new DownloadFileRequest(compareResult.Path);
            using (var resultStream = storageApi.DownloadFile(downloadRequest))
            using (var fileStream = new FileStream(localResultPath, FileMode.Create, FileAccess.Write))
            {
                resultStream.CopyTo(fileStream);
            }

// Optional: clean up remote files
            storageApi.DeleteFile(new DeleteFileRequest(remoteFilePath1));
            storageApi.DeleteFile(new DeleteFileRequest(remoteFilePath2));
            storageApi.DeleteFile(new DeleteFileRequest(remoteResultPath));

Console.WriteLine("Comparison completed. Result saved to " + localResultPath);
        }
    }
}

Nota: Este ejemplo de código demuestra la funcionalidad principal. Antes de usarlo en su proyecto, asegúrese de actualizar cualquier ruta de archivo y valores de configuración para que coincidan con su entorno real, verifique que todas las dependencias requeridas estén instaladas correctamente y realice pruebas exhaustivas en su entorno de desarrollo. Si encuentra algún problema, consulte la documentación oficial o póngase en contacto con el equipo de soporte para obtener ayuda.

Llamando a la API REST de Comparison con cURL

A continuación se muestra un flujo de trabajo cURL que realiza la misma operación sin escribir código C#. Reemplace los valores de marcador de posición con sus credenciales reales y los nombres de archivo.

Obtener un token de acceso

curl -X POST "https://api.groupdocs.cloud/v2.0/oauth2/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

Cargar el archivo XLSX de origen

curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/sample1.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" \
     --data-binary "@sample1.xlsx"

Cargar el archivo XLSX de destino

curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/sample2.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" \
     --data-binary "@sample2.xlsx"

Ejecutar la comparación

curl -X POST "https://api.groupdocs.cloud/v2.0/comparison/compare" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "source_file": {"file_path": "sample1.xlsx"},
           "target_files": [{"file_path": "sample2.xlsx"}],
           "output_path": "result.xlsx",
           "settings": {
               "generate_summary_page": true,
               "show_deleted_content": true,
               "show_inserted_content": true
           }
         }'

Descargar el resultado

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/result.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o result.xlsx

Para obtener una lista completa de endpoints y parámetros, consulte la documentación oficial de la API.

Requisitos y Configuración

Instale el paquete .NET a través de NuGet:

dotnet add package GroupDocs.Comparison-Cloud

Asegúrese de tener una cuenta válida de GroupDocs Cloud y obtenga su Client Id y Client Secret desde el panel.
Se requiere .NET 6.0 o posterior.

Puede descargar la última biblioteca desde la página de descarga.

Ajuste fino de la configuración de comparación

El objeto Settings dentro de CompareOptions le permite controlar la salida. Los ajustes comunes incluyen:

GenerateSummaryPage - agrega una hoja de resumen con estadísticas de cambios.
ShowDeletedContent - resalta las celdas que fueron eliminadas.
ShowInsertedContent - resalta las celdas recién añadidas.

Estas propiedades ya se utilizan en el ejemplo de código anterior. Para opciones adicionales, como la protección Password o StyleChangeDetection, consulte la Referencia de API.

Conclusión

Comparar archivos Excel a través de REST en C# se vuelve sencillo con el GroupDocs.Comparison Cloud SDK for .NET. Siguiendo los pasos, puedes cargar archivos XLSX, configurar ajustes de comparación detallados, ejecutar la comparación y obtener un libro de resultados que marca claramente las diferencias. Recuerda asegurar tus credenciales API, respetar los límites de tamaño de archivo y usar una licencia temporal para desarrollo. Cuando estés listo para producción, adquiere una licencia completa desde la página de precios para desbloquear uso ilimitado.

Preguntas frecuentes

¿Cómo comparo archivos Excel mediante REST en C# usando GroupDocs.Comparison?
Use el SDK para cargar dos archivos XLSX, establezca CompareOptions, llame a CompareDocument y descargue el archivo resultante. El flujo de trabajo completo se ilustra en las secciones de código y cURL anteriores.
¿Qué método de autenticación requiere la API REST?
La API utiliza OAuth 2.0 con su client‑id y client‑secret para obtener un token de acceso, que debe enviarse en el encabezado Authorization: Bearer en cada solicitud.
¿Puedo personalizar qué cambios se resaltan en el resultado de la comparación?
Sí. Ajuste el objeto Settings (p. ej., GenerateSummaryPage, ShowDeletedContent, ShowInsertedContent) para controlar la apariencia de las diferencias.
¿Es suficiente una licencia temporal para pruebas?
Una licencia temporal de la página de licencias temporales funciona para desarrollo y pruebas. Para implementaciones en producción, adquiera una licencia completa.

Leer más

Comparar archivos de Excel mediante REST en C#

Mon, 21 Sep 2026 11:32:39 +0000

Analizando los cambios entre versiones de hojas de cálculo es una tarea rutinaria para flujos de trabajo de finanzas, informes y validación de datos. GroupDocs.Comparison Cloud SDK for .NET proporciona una API potente que facilita la comparación de archivos Excel en .NET sin inspección manual. En esta guía verá cómo configurar la biblioteca, cargar libros de trabajo, llamar al endpoint REST desde C#, obtener información detallada de los cambios y ajustar finamente las opciones de comparación para obtener resultados precisos.

Antes de comenzar: Requisitos previos e instalación

Antes de comenzar, asegúrese de tener lo siguiente:

.NET 6.0 o posterior instalado.
Un IDE como Visual Studio 2022.
Una cuenta de GroupDocs Cloud con ClientId y ClientSecret.
Acceso al almacenamiento de GroupDocs Cloud donde se cargarán los archivos Excel.

Instale el SDK a través de NuGet:

dotnet add package GroupDocs.Comparison-Cloud

Descargue el paquete más reciente desde la página de lanzamiento. Después de la instalación, agregue sus credenciales en el código como se muestra más adelante. Ahora está listo para iniciar el flujo de trabajo de comparación.

Guía paso a paso para comparar archivos Excel en .NET

Los siguientes pasos ilustran cómo comparar archivos Excel en .NET usando el SDK.

Paso 1: Cargar los documentos de origen y destino

Cree un objeto de configuración con sus credenciales e instancie el CompareApi.

var config = new Configuration
{
    ClientId = "YOUR_CLIENT_ID",
    ClientSecret = "YOUR_CLIENT_SECRET"
};

var compareApi = new CompareApi(config);

Paso 2: Preparar los libros de Excel

Defina objetos FileInfo que apunten a los archivos XLSX de origen y destino almacenados en el almacenamiento de GroupDocs Cloud.

var sourceFile = new FileInfo { FilePath = "input/source.xlsx" };
var targetFile = new FileInfo { FilePath = "input/target.xlsx" };

Paso 3: Configurar opciones y ajustes de comparación

Configure el objeto CompareOptions, incluyendo configuraciones detalladas de cambios.

var compareOptions = new CompareOptions
{
    SourceFile = sourceFile,
    TargetFiles = new List { targetFile },
    OutputPath = "output/diff_result.xlsx",
    Settings = new Settings
    {
        ShowDeletedContent = true,
        ShowInsertedContent = true,
        ShowStyleChanges = true,
        GenerateSummaryPage = true
    }
};

Para obtener una lista completa de configuraciones, consulte la referencia de API.

Paso 4: Ejecutar la Comparación y Procesar los Resultados

Llame al método Compare y lea la información básica del resultado.

var compareResult = compareApi.Compare(compareOptions);
Console.WriteLine($"Comparison completed. Result file: {compareResult.Path}");
Console.WriteLine($"Number of changes detected: {compareResult.Changes?.Count ?? 0}");

Paso 5: Recuperar información detallada del cambio

Si necesita un informe granular, use la solicitud GetChanges.

var changesRequest = new GetChangesRequest
{
    SourceFile = sourceFile,
    TargetFile = targetFile,
    OutputPath = "output/detailed_changes.json"
};
var detailedChanges = compareApi.GetChanges(changesRequest);
Console.WriteLine($"Detailed changes saved to: {detailedChanges.Path}");

Con estos pasos has automatizado completamente el proceso de comparar archivos Excel en .NET.

Comparar archivos de Excel programáticamente - Ejemplo de código completo

El siguiente código muestra el flujo de trabajo completo desde la configuración hasta el manejo del resultado.

using System;
using System.Collections.Generic;
using GroupDocs.Comparison.Cloud.Sdk.Api;
using GroupDocs.Comparison.Cloud.Sdk.Client;
using GroupDocs.Comparison.Cloud.Sdk.Model;

namespace CompareExcelDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set up API credentials (replace with your actual credentials)
            var config = new Configuration
            {
                ClientId = "YOUR_CLIENT_ID",
                ClientSecret = "YOUR_CLIENT_SECRET"
            };

// Initialize Compare API
            var compareApi = new CompareApi(config);

// Prepare source and target Excel files (must be uploaded to GroupDocs Cloud storage beforehand)
            var sourceFile = new FileInfo { FilePath = "input/source.xlsx" };
            var targetFile = new FileInfo { FilePath = "input/target.xlsx" };

// Define comparison options
            var compareOptions = new CompareOptions
            {
                SourceFile = sourceFile,
                TargetFiles = new List { targetFile },
                OutputPath = "output/diff_result.xlsx",
                // Optional: specify that we want detailed changes for worksheets
                Settings = new Settings
                {
                    ShowDeletedContent = true,
                    ShowInsertedContent = true,
                    ShowStyleChanges = true,
                    GenerateSummaryPage = true
                }
            };

try
            {
                // Call the Compare API
                var compareResult = compareApi.Compare(compareOptions);

// Output basic result information
                Console.WriteLine($"Comparison completed. Result file: {compareResult.Path}");
                Console.WriteLine($"Number of changes detected: {compareResult.Changes?.Count ?? 0}");

// Iterate through change details
                if (compareResult.Changes != null)
                {
                    foreach (var change in compareResult.Changes)
                    {
                        Console.WriteLine("--------------------------------------------------");
                        Console.WriteLine($"Change Type   : {change.ChangeType}");
                        Console.WriteLine($"Worksheet     : {change.Worksheet}");
                        Console.WriteLine($"Cell Address  : {change.CellAddress}");
                        Console.WriteLine($"Old Value     : {change.OldValue}");
                        Console.WriteLine($"New Value     : {change.NewValue}");
                        Console.WriteLine($"Is New Row    : {change.IsNewRow}");
                        Console.WriteLine($"Is New Column : {change.IsNewColumn}");
                    }
                }

// Retrieve detailed changes via GetChanges (optional)
                var changesRequest = new GetChangesRequest
                {
                    SourceFile = sourceFile,
                    TargetFile = targetFile,
                    OutputPath = "output/detailed_changes.json"
                };
                var detailedChanges = compareApi.GetChanges(changesRequest);
                Console.WriteLine($"Detailed changes saved to: {detailedChanges.Path}");
            }
            catch (ApiException apiEx)
            {
                Console.WriteLine($"API error: {apiEx.ErrorCode} - {apiEx.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Unexpected error: {ex.Message}");
            }
        }
    }
}

Nota: Este ejemplo de código muestra la funcionalidad principal. Antes de usarlo en su proyecto, asegúrese de actualizar cualquier ruta de archivo y valores de configuración para que coincidan con su entorno real, verifique que todas las dependencias requeridas estén correctamente instaladas y pruebe exhaustivamente en su entorno de desarrollo. Si encuentra algún problema, consulte la documentación oficial o póngase en contacto con el equipo de soporte para obtener ayuda.

Realizar comparación de Excel via REST con cURL

Puedes lograr el mismo resultado sin escribir código C# llamando directamente a la API REST.

1. Autenticar y obtener token de acceso

curl -X POST "https://api.groupdocs.cloud/v1.0/oauth2/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

2. Cargar el libro de trabajo de origen

curl -X PUT "https://api.groupdocs.cloud/v1.0/storage/file?path=input/source.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -T "./source.xlsx"

3. Cargar el libro de trabajo objetivo

curl -X PUT "https://api.groupdocs.cloud/v1.0/storage/file?path=input/target.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -T "./target.xlsx"

4. Ejecutar la Comparación

curl -X POST "https://api.groupdocs.cloud/v1.0/comparison/compare" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "source_file": {"file_path":"input/source.xlsx"},
           "target_files": [{"file_path":"input/target.xlsx"}],
           "output_path":"output/diff_result.xlsx",
           "settings": {
               "show_deleted_content": true,
               "show_inserted_content": true,
               "show_style_changes": true,
               "generate_summary_page": true
           }
         }'

5. Descargar el libro de trabajo de diferencias resultante

curl -X GET "https://api.groupdocs.cloud/v1.0/storage/file?path=output/diff_result.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o diff_result.xlsx

Para obtener una lista completa de los parámetros, consulte la documentación oficial de la API.

Conclusión

Usando el GroupDocs.Comparison Cloud SDK for .NET puedes comparar fácilmente archivos Excel en .NET y obtener un libro de trabajo de diferencias detallado que resalta cada modificación. La arquitectura basada en REST del SDK te permite integrar la comparación de hojas de cálculo en cualquier servicio C#, API web o trabajo en segundo plano con un esfuerzo mínimo. Recuerda adquirir una licencia adecuada para uso en producción; una licencia temporal está disponible en la página de licencias y los detalles completos de licenciamiento se enumeran en el sitio del producto. Comienza a automatizar tus flujos de trabajo de diferencias de Excel hoy y elimina los errores de inspección manual.

Preguntas frecuentes

¿Cómo puedo comparar archivos Excel en .NET sin escribir mucho código?
El SDK abstrae el trabajo pesado. Solo necesita configurar credenciales, apuntar a los dos archivos XLSX y llamar a compareApi.Compare. La biblioteca devuelve un archivo diff y una lista de objetos de cambio.
¿Qué formato usa el resultado del diff?
Por defecto, el resultado se guarda como un libro de trabajo XLSX, preservando el diseño original mientras se aplican marcadores visuales para eliminaciones, inserciones y cambios de estilo.
¿Es posible comparar libros de Excel protegidos?
Sí. Proporcione la contraseña en la propiedad Password del objeto FileInfo. La API desbloqueará el libro antes de realizar la comparación.
¿Necesito una licencia para desarrollo y pruebas?
Se puede obtener una licencia temporal desde la página de licencias. Para implementaciones en producción debe adquirir una licencia completa como se describe en la página del producto.