Comment comparer des fichiers Excel en .NET

Vous êtes-vous déjà retrouvé à vérifier manuellement les différences entre deux fichiers Excel ? Que vous suiviez les changements dans les rapports financiers, compariez des versions de jeux de données ou audité la cohérence des données, la comparaison manuelle est à la fois chronophage et sujette aux erreurs. Dans ce guide, vous apprendrez à comparer des fichiers Excel rapidement et de manière fiable en utilisant GroupDocs.Comparison pour .NET.

Réponses rapides

• Quelle bibliothèque puis‑je utiliser ? GroupDocs.Comparison for .NET
• Combien de lignes de code sont nécessaires ? Moins de 10 lignes pour un diff de base
• Puis‑je comparer de grands classeurs Excel ? Oui – utilisez les options de performance pour gérer les gros fichiers
• Ai‑je besoin d’une licence ? Un essai gratuit suffit pour les tests ; une licence commerciale est requise pour la production
• Est‑il possible d’automatiser la comparaison Excel dans une API web ? Absolument – voir l’exemple de contrôleur ASP.NET

Pourquoi comparer les fichiers Excel de manière programmatique ?

Avant de plonger dans le code, parlons des raisons pour lesquelles la comparaison automatisée d’Excel est un véritable atout :

• Contrôle de version – Suivez automatiquement les changements entre les versions de documents sans ouvrir les fichiers manuellement
• Audit des données – Assurez la cohérence des données entre les services et les systèmes
• Assurance qualité – Détectez les divergences dans les rapports avant qu’elles n’atteignent les parties prenantes
• Automatisation des flux de travail – Intégrez la logique de comparaison dans des processus métier plus larges

La bibliothèque GroupDocs.Comparison se charge de toute la lourde tâche, vous n’avez donc pas à vous soucier de l’analyse des formats Excel ou de l’implémentation d’algorithmes de diff complexes.

Qu’est‑ce qu’un outil de diff de fichiers Excel ?

Un outil de diff de fichiers Excel compare deux versions de feuilles de calcul et met en évidence les ajouts, suppressions et modifications. GroupDocs.Comparison agit comme un puissant outil de diff programmatique qui fonctionne directement depuis votre code .NET.

Prérequis et configuration

Ce dont vous avez besoin

• Environnement de développement : Visual Studio 2019 ou ultérieur (VS Code fonctionne également)
• Bibliothèque GroupDocs.Comparison : Version 25.4.0 ou ultérieure
• Connaissances de base : Familiarité avec C# et la gestion de fichiers en .NET
• Fichiers d’exemple : Deux fichiers Excel pour les tests (nous vous montrerons comment créer des scénarios de test)

Installation de GroupDocs.Comparison pour .NET

Vous avez plusieurs options d’installation :

Option 1 : Console du gestionnaire de packages NuGet

dotnet add package GroupDocs.Comparison --version 25.4.0

Option 2 : Console du gestionnaire de packages Visual Studio

1. Faites un clic droit sur votre projet dans l’Explorateur de solutions
2. Sélectionnez Manage NuGet Packages
3. Recherchez GroupDocs.Comparison
4. Installez la version la plus récente

Options de licence

Lorsque vous débutez, vous pouvez utiliser GroupDocs.Comparison avec un essai gratuit. Pour une utilisation en production, vous aurez besoin d’une licence :

• Essai gratuit : Fonctionnalité complète avec filigranes d’évaluation
• Licence temporaire : Request here pour les tests
• Licence commerciale : Purchase options pour une utilisation en production

Comment comparer des fichiers Excel avec GroupDocs.Comparison

Construisons maintenant une solution complète de comparaison de fichiers Excel. Nous commencerons simplement et ajouterons des fonctionnalités plus sophistiquées au fur et à mesure.

Étape 1 : Configuration de base du projet

Tout d’abord, créez un nouveau projet C# et ajoutez les déclarations using nécessaires :

using GroupDocs.Comparison;
using System;
using System.IO;

Étape 2 : Configurer les chemins de fichiers

Configurez vos chemins de fichiers de manière claire et maintenable :

string documentDirectory = "YOUR_DOCUMENT_DIRECTORY";
string resultOutputDirectory = "YOUR_OUTPUT_DIRECTORY";

string sourceFilePath = Path.Combine(documentDirectory, "source_cells.xlsx");
string targetFilePath = Path.Combine(documentDirectory, "target_cells.xlsx");
string resultFilePath = Path.Combine(resultOutputDirectory, "comparison_result.xlsx");

Astuce : Utilisez des chemins relatifs pour une meilleure portabilité entre les environnements de développement. Quelque chose comme Path.Combine("TestData", "source_cells.xlsx") fonctionne très bien dans la plupart des scénarios.

Étape 3 : Initialiser le Comparateur

C’est ici que la magie opère. La classe Comparer est votre point d’entrée pour toutes les opérations de comparaison :

using (Comparer comparer = new Comparer(sourceFilePath))
{
    // Add target file for comparison
    comparer.Add(targetFilePath);
}

Que se passe‑t‑il ici ? Le constructeur Comparer charge votre fichier Excel source en mémoire et le prépare à la comparaison. L’instruction using garantit un nettoyage approprié des ressources – c’est crucial lorsqu’on manipule des fichiers Excel potentiellement volumineux.

Étape 4 : Exécuter la comparaison

Passons maintenant à la comparaison réelle. C’est étonnamment simple :

using (Comparer comparer = new Comparer(sourceFilePath))
{
    comparer.Add(targetFilePath);
    // Compare and save results
    comparer.Compare(resultFilePath);
}

En coulisses, GroupDocs.Comparison analyse les deux fichiers cellule par cellule, en identifiant :

• Lignes et colonnes ajoutées
• Contenu supprimé
• Valeurs de cellules modifiées
• Modifications de mise en forme
• Différences de formules

Les résultats sont enregistrés dans le fichier de sortie spécifié avec les différences clairement mises en évidence.

Étape 5 : Exemple complet fonctionnel

Voici un exemple complet, prêt pour la production, que vous pouvez utiliser immédiatement :

using GroupDocs.Comparison;
using System;
using System.IO;

class Program
{
    static Main()
    {
        try
        {
            // Set up file paths
            string documentDirectory = @"C:\TestFiles";
            string outputDirectory = @"C:\ComparisonResults";
            
            string sourceFile = Path.Combine(documentDirectory, "quarterly_report_v1.xlsx");
            string targetFile = Path.Combine(documentDirectory, "quarterly_report_v2.xlsx");
            string resultFile = Path.Combine(outputDirectory, "comparison_result.xlsx");
            
            // Ensure output directory exists
            Directory.CreateDirectory(outputDirectory);
            
            // Perform comparison
            using (Comparer comparer = new Comparer(sourceFile))
            {
                comparer.Add(targetFile);
                comparer.Compare(resultFile);
            }
            
            Console.WriteLine($"Comparison complete! Results saved to: {resultFile}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error during comparison: {ex.Message}");
        }
    }
}

Automatiser la comparaison Excel – Options de configuration avancées

La comparaison de base est puissante, mais vous pourriez avoir besoin de plus de contrôle sur le processus. Voici quelques options avancées.

Personnalisation des paramètres de comparaison

using (Comparer comparer = new Comparer(sourceFilePath))
{
    comparer.Add(targetFilePath);
    
    // Configure comparison options
    CompareOptions options = new CompareOptions()
    {
        ShowRevisions = true,
        DetectStyleChanges = true,
        GenerateSummaryPage = true
    };
    
    comparer.Compare(resultFilePath, options);
}

Comparaison de plusieurs fichiers

Besoin de comparer plus de deux fichiers ? Aucun problème :

using (Comparer comparer = new Comparer(sourceFilePath))
{
    comparer.Add(targetFile1Path);
    comparer.Add(targetFile2Path);
    comparer.Add(targetFile3Path);
    
    comparer.Compare(resultFilePath);
}

Exemples d’implémentation réels

Scénario 1 : Validation de rapports financiers

public class FinancialReportValidator
{
    public bool ValidateReportChanges(string previousReport, string currentReport)
    {
        string comparisonResult = Path.GetTempFileName() + ".xlsx";
        
        using (Comparer comparer = new Comparer(previousReport))
        {
            comparer.Add(currentReport);
            comparer.Compare(comparisonResult);
            
            // Check if there are significant changes
            return HasSignificantChanges(comparisonResult);
        }
    }
    
    private bool HasSignificantChanges(string comparisonFile)
    {
        // Your business logic here
        // For example, check if revenue columns changed by more than 5%
        return false;
    }
}

Scénario 2 : Vérification de migration de données

public class DataMigrationValidator
{
    public async Task<bool> VerifyMigration(string sourceData, string migratedData)
    {
        try
        {
            string resultPath = $"migration_validation_{DateTime.Now:yyyyMMdd_HHmmss}.xlsx";
            
            using (Comparer comparer = new Comparer(sourceData))
            {
                comparer.Add(migratedData);
                comparer.Compare(resultPath);
            }
            
            // Send result to stakeholders
            await NotifyStakeholders(resultPath);
            return true;
        }
        catch (Exception ex)
        {
            // Log error and handle gracefully
            Console.WriteLine($"Migration validation failed: {ex.Message}");
            return false;
        }
    }
}

Problèmes courants et solutions

Même avec une API simple, vous pouvez rencontrer des défis. Voici les problèmes les plus courants et comment les résoudre.

Problème 1 : « File is being used by another process »

Problème : Les fichiers Excel sont verrouillés par d’autres applications.
Solution : Utilisez toujours les instructions using et assurez‑vous qu’Excel n’est pas ouvert :

// Good practice
using (Comparer comparer = new Comparer(sourceFilePath))
{
    // Your comparison logic
}

// Check if file is in use before comparison
private bool IsFileLocked(string filePath)
{
    try
    {
        using (FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.None))
        {
            return false;
        }
    }
    catch (IOException)
    {
        return true;
    }
}

Problème 2 : Performance avec les gros fichiers

Problème : La comparaison prend trop de temps avec de gros fichiers Excel.
Solution : Envisagez ces stratégies d’optimisation :

// Process files in chunks or limit comparison scope
CompareOptions options = new CompareOptions()
{
    // Only compare content, skip formatting for speed
    DetectStyleChanges = false,
    
    // Limit comparison to specific ranges if possible
    // Note: Range limitation may require custom implementation
};

Problème 3 : Consommation de mémoire

Problème : L’application utilise trop de mémoire avec de gros fichiers.
Solution : Mettez en œuvre une gestion appropriée des ressources :

public void CompareFilesWithMemoryManagement(string source, string target, string output)
{
    // Ensure garbage collection
    GC.Collect();
    GC.WaitForPendingFinalizers();
    
    using (Comparer comparer = new Comparer(source))
    {
        comparer.Add(target);
        comparer.Compare(output);
    }
    
    // Force cleanup
    GC.Collect();
}

Conseils d’optimisation des performances – Détecter les changements Excel plus rapidement

Meilleures pratiques de gestion de la mémoire

1. Utilisez toujours les instructions using pour la libération automatique des ressources
2. Traitez les fichiers séquentiellement plutôt qu’en parallèle pour les gros fichiers
3. Prenez en compte les limites de taille de fichier – divisez les fichiers massifs en morceaux plus petits
4. Surveillez l’utilisation de la mémoire pendant le développement et les tests

Optimisation de la vitesse

// Optimize for speed
CompareOptions fastOptions = new CompareOptions()
{
    DetectStyleChanges = false,        // Skip formatting comparison
    ShowRevisions = false,             // Skip revision tracking
    GenerateSummaryPage = false        // Skip summary generation
};

Stratégie de traitement par lots – Comparer efficacement de grands classeurs Excel

public async Task CompareMultipleFilePairs(List<(string source, string target)> filePairs)
{
    foreach (var (source, target) in filePairs)
    {
        string output = $"comparison_{Path.GetFileNameWithoutExtension(source)}.xlsx";
        
        using (Comparer comparer = new Comparer(source))
        {
            comparer.Add(target);
            comparer.Compare(output);
        }
        
        // Small delay to prevent resource exhaustion
        await Task.Delay(100);
    }
}

Intégration avec les applications ASP.NET – Automatiser la comparaison Excel via une API

Vous souhaitez ajouter la comparaison Excel à votre application web ? Voici un exemple de contrôleur de base :

[ApiController]
[Route("api/[controller]")]
public class ExcelComparisonController : ControllerBase
{
    [HttpPost("compare")]
    public async Task<IActionResult> CompareExcelFiles(IFormFile sourceFile, IFormFile targetFile)
    {
        if (sourceFile == null || targetFile == null)
            return BadRequest("Both source and target files are required.");
        
        try
        {
            // Save uploaded files temporarily
            string tempDir = Path.GetTempPath();
            string sourcePath = Path.Combine(tempDir, sourceFile.FileName);
            string targetPath = Path.Combine(tempDir, targetFile.FileName);
            string resultPath = Path.Combine(tempDir, $"comparison_{Guid.NewGuid()}.xlsx");
            
            using (var sourceStream = new FileStream(sourcePath, FileMode.Create))
            {
                await sourceFile.CopyToAsync(sourceStream);
            }
            
            using (var targetStream = new FileStream(targetPath, FileMode.Create))
            {
                await targetFile.CopyToAsync(targetStream);
            }
            
            // Perform comparison
            using (Comparer comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath);
            }
            
            // Return result file
            var resultBytes = await System.IO.File.ReadAllBytesAsync(resultPath);
            
            // Cleanup temporary files
            System.IO.File.Delete(sourcePath);
            System.IO.File.Delete(targetPath);
            System.IO.File.Delete(resultPath);
            
            return File(resultBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "comparison_result.xlsx");
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Comparison failed: {ex.Message}");
        }
    }
}

Quand utiliser la comparaison de fichiers Excel

La comparaison Excel est particulièrement utile dans les scénarios suivants :

Services financiers

• Revue des rapports trimestriels – comparer les rapports du trimestre en cours avec ceux du trimestre précédent
• Suivi du budget – surveiller les changements budgétaires entre les services
• Préparation d’audit – garantir la cohérence des données avant les audits externes

Gestion des données

• Validation ETL – vérifier les transformations de données lors de la migration
• Assurance qualité – s’assurer que les données importées correspondent aux systèmes sources
• Contrôle de version – suivre les changements dans les fichiers de données maîtres

Business Intelligence

• Validation de rapports – comparer les rapports automatisés avec les calculs manuels
• Réconciliation des données – faire correspondre les données entre différents systèmes
• Suivi des changements – surveiller les évolutions des KPI au fil du temps

Foire aux questions

Q : Quelle est la taille maximale de fichier que GroupDocs.Comparison peut gérer ?
R : La bibliothèque peut gérer des fichiers jusqu’à plusieurs centaines de Mo, mais les performances dépendent de la mémoire disponible. Pour les fichiers supérieurs à 50 Mo, envisagez une traitement par morceaux ou des approches de streaming.

Q : Puis‑je comparer des fichiers Excel protégés par mot de passe ?
R : Oui, mais vous devez fournir le mot de passe lors du processus de comparaison. La bibliothèque prend en charge les fichiers Excel chiffrés avec les informations d’identification appropriées.

Q : Quelle est la précision de la comparaison pour des fichiers Excel complexes avec des formules ?
R : GroupDocs.Comparison détecte avec précision les changements de formules, y compris les références de cellules et les modifications de fonctions. Il considère les formules comme des changements de contenu et les met en évidence en conséquence.

Q : Puis‑je personnaliser la sortie visuelle des résultats de comparaison ?
R : La bibliothèque propose plusieurs styles de mise en évidence intégrés. Pour un style personnalisé, vous pouvez post‑traiter le fichier de sortie ou explorer les options de style de l’API.

Q : Existe‑t‑il un moyen de comparer uniquement des feuilles de calcul spécifiques dans un fichier Excel ?
R : Bien que la bibliothèque compare par défaut l’ensemble du fichier, vous pouvez pré‑traiter les fichiers pour extraire les feuilles spécifiques avant la comparaison, ou post‑traiter les résultats pour filtrer les changements pertinents.

Q : Comment GroupDocs.Comparison détecte‑t‑il les changements dans Excel ?
R : Il effectue un diff cellule par cellule, en vérifiant les valeurs, les formules, la mise en forme et les modifications structurelles telles que l’ajout ou la suppression de lignes/colonnes.

Q : L’outil fonctionne‑t‑il bien avec des classeurs Excel très volumineux ?
R : Oui – en désactivant la détection de style (DetectStyleChanges = false) et en utilisant le traitement par lots, vous pouvez comparer efficacement de gros fichiers Excel.

Ressources supplémentaires

• Documentation : GroupDocs Comparison .NET Documentation
• Référence API : GroupDocs Comparison .NET API Reference
• Téléchargement : GroupDocs Releases for .NET
• Acheter une licence GroupDocs : Buy GroupDocs License
• Essai gratuit : GroupDocs Free Trial
• Licence temporaire : Request Temporary License
• Forum de support : GroupDocs Support Community

Dernière mise à jour : 2026-04-10
Testé avec : GroupDocs.Comparison 25.4.0
Auteur : GroupDocs