Comment transformer les réponses API en rapports Excel en C#

Dans le monde axé sur les données d’aujourd’hui, les entreprises s’appuient fortement sur les API REST pour l’échange de données. Cependant, de nombreux acteurs préfèrent consommer ces données au format Excel pour l’analyse et la création de rapports. Ce guide démontre comment construire une application C# complète qui :

Se connecte aux API REST
Récupère les données de réponse JSON
Convertit les données en rapports Excel au format professionnel
Ajoute des visualisations avec des graphiques et des tableaux

Valeur commerciale

Cette solution apporte une valeur significative en :

Automatisant les processus d’extraction de données manuelle et de création de rapports
Assurant l’exactitude des données en éliminant la copie manuelle
Fournissant un format de rapport cohérent
Permettant la génération de rapports programmés

Guide d’implémentation étape par étape

Étape 1 : Créer une nouvelle application C#

Commencez par créer une nouvelle application console :

dotnet new console -n ApiToExcelReporter
cd ApiToExcelReporter

Étape 2 : Installer les packages requis

Ajoutez les packages NuGet nécessaires :

dotnet add package Aspose.Cells
dotnet add package Newtonsoft.Json
dotnet add package RestSharp

Étape 3 : Implémenter le client API REST

Créez un service pour la communication API :

using RestSharp;
using Newtonsoft.Json;
using System;
using System.Threading.Tasks;

public class ApiService
{
    private readonly RestClient _client;
    
    public ApiService(string baseUrl)
    {
        _client = new RestClient(baseUrl);
    }
    
    public async Task<T> GetApiDataAsync<T>(string endpoint, string apiKey = null)
    {
        var request = new RestRequest(endpoint, Method.Get);
        
        // Ajouter l'authentification si nécessaire
        if (!string.IsNullOrEmpty(apiKey))
        {
            request.AddHeader("Authorization", $"Bearer {apiKey}");
        }
        
        var response = await _client.ExecuteAsync(request);
        
        if (response.IsSuccessful)
        {
            return JsonConvert.DeserializeObject<T>(response.Content);
        }
        
        throw new Exception($"L'appel API a échoué : {response.ErrorMessage}");
    }
}

Étape 4 : Traiter les données de réponse JSON

Ajoutez une classe pour traiter les données JSON :

using Newtonsoft.Json.Linq;
using System.Collections.Generic;

public class DataProcessor
{
    public List<Dictionary<string, object>> FlattenJsonData(string jsonData)
    {
        var results = new List<Dictionary<string, object>>();
        JToken token = JToken.Parse(jsonData);
        
        // Gérer différentes structures JSON
        if (token is JArray array)
        {
            foreach (var item in array)
            {
                results.Add(FlattenObject(item));
            }
        }
        else if (token is JObject obj)
        {
            // Pour les données imbriquées comme {"data": [{...}, {...}]}
            var dataToken = obj["data"] as JArray;
            if (dataToken != null)
            {
                foreach (var item in dataToken)
                {
                    results.Add(FlattenObject(item));
                }
            }
            else
            {
                results.Add(FlattenObject(obj));
            }
        }
        
        return results;
    }
    
    private Dictionary<string, object> FlattenObject(JToken token)
    {
        var result = new Dictionary<string, object>();
        FillDictionary(result, token, "");
        return result;
    }
    
    private void FillDictionary(Dictionary<string, object> dict, JToken token, string prefix)
    {
        switch (token.Type)
        {
            case JTokenType.Object:
                foreach (var prop in token.Children<JProperty>())
                {
                    FillDictionary(dict, prop.Value, 
                        string.IsNullOrEmpty(prefix) ? prop.Name : $"{prefix}.{prop.Name}");
                }
                break;
                
            case JTokenType.Array:
                int index = 0;
                foreach (var item in token.Children())
                {
                    FillDictionary(dict, item, $"{prefix}[{index}]");
                    index++;
                }
                break;
                
            default:
                dict[prefix] = ((JValue)token).Value;
                break;
        }
    }
}

Étape 5 : Convertir en Excel avec Aspose.Cells

Implémentez la conversion Excel :

using Aspose.Cells;
using Aspose.Cells.Utility;
using System;
using System.Collections.Generic;
using System.IO;

public class ExcelReportGenerator
{
    public void GenerateReport(string jsonData, string outputPath)
    {
        // Créer un nouveau classeur
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];
        
        // Configurer les options de mise en page JSON
        JsonLayoutOptions options = new JsonLayoutOptions
        {
            ArrayAsTable = true,
            ConvertNumericOrDate = true,
            IgnoreNull = true
        };
        
        // Mettre les en-têtes en gras
        options.TitleStyle = new CellsFactory().CreateStyle();
        options.TitleStyle.Font.IsBold = true;
        
        // Importer les données JSON
        JsonUtility.ImportData(jsonData, sheet.Cells, 0, 0, options);
        
        // Ajuster automatiquement les colonnes
        sheet.AutoFitColumns();
        
        // Enregistrer le classeur
        workbook.Save(outputPath);
    }
    
    public void GenerateReportFromObjects(List<Dictionary<string, object>> data, string outputPath)
    {
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];
        
        // Ajouter des en-têtes s'il y a des données
        if (data.Count > 0)
        {
            int col = 0;
            foreach (var key in data[0].Keys)
            {
                // Ajouter l'en-tête avec style
                Cell cell = sheet.Cells[0, col];
                cell.PutValue(key);
                
                Style style = cell.GetStyle();
                style.Font.IsBold = true;
                cell.SetStyle(style);
                
                col++;
            }
            
            // Ajouter des lignes de données
            for (int row = 0; row < data.Count; row++)
            {
                col = 0;
                foreach (var value in data[row].Values)
                {
                    sheet.Cells[row + 1, col].PutValue(value);
                    col++;
                }
            }
        }
        
        // Formater en tant que tableau
        if (data.Count > 0)
        {
            int lastRow = data.Count;
            int lastCol = data[0].Count - 1;
            
            var tableRange = sheet.Cells.CreateRange(0, 0, lastRow + 1, lastCol + 1);
            sheet.ListObjects.Add(tableRange, "DataTable");
        }
        
        // Ajuster automatiquement les colonnes
        sheet.AutoFitColumns();
        
        // Enregistrer le classeur
        workbook.Save(outputPath);
    }
}

Étape 6 : Ajouter un formatage professionnel

Améliorez la sortie Excel avec un style professionnel :

public void ApplyProfessionalFormatting(Workbook workbook)
{
    Worksheet sheet = workbook.Worksheets[0];
    
    // Créer un style pour le titre
    Style titleStyle = workbook.CreateStyle();
    titleStyle.Font.Size = 14;
    titleStyle.Font.IsBold = true;
    titleStyle.HorizontalAlignment = TextAlignmentType.Center;
    
    // Ajouter un titre au rapport
    sheet.Cells.Merge(0, 0, 1, sheet.Cells.MaxColumn + 1);
    Cell titleCell = sheet.Cells[0, 0];
    titleCell.PutValue("Rapport de données API - " + DateTime.Now.ToString("yyyy-MM-dd"));
    titleCell.SetStyle(titleStyle);
    
    // Insérer une ligne vide après le titre
    sheet.Cells.InsertRow(1);
    
    // Appliquer des couleurs de lignes alternées aux données
    Style evenRowStyle = workbook.CreateStyle();
    evenRowStyle.ForegroundColor = Color.FromArgb(240, 240, 240);
    evenRowStyle.Pattern = BackgroundType.Solid;
    
    int dataStartRow = 3; // Comptabiliser le titre et la ligne vide
    int lastRow = sheet.Cells.MaxRow;
    
    for (int row = dataStartRow; row <= lastRow; row += 2)
    {
        for (int col = 0; col <= sheet.Cells.MaxColumn; col++)
        {
            sheet.Cells[row, col].SetStyle(evenRowStyle);
        }
    }
    
    // Ajouter un en-tête et un pied de page
    sheet.PageSetup.SetHeader(1, "&\"Arial,Bold\"&14Rapport API");
    sheet.PageSetup.SetFooter(1, "Page &P sur &N");
    
    // Définir les options d'impression
    sheet.PageSetup.Orientation = PageOrientationType.Landscape;
    sheet.PageSetup.FitToPagesWide = 1;
    sheet.PageSetup.TopMargin = 0.5;
    sheet.PageSetup.LeftMargin = 0.5;
    sheet.PageSetup.RightMargin = 0.5;
    sheet.PageSetup.BottomMargin = 0.5;
}

Étape 7 : Ajouter une visualisation des données

Améliorez le rapport avec des graphiques :

public void AddChartVisualization(Workbook workbook, int dataColumn)
{
    Worksheet sheet = workbook.Worksheets[0];
    Worksheet chartSheet = workbook.Worksheets.Add("Analyse des graphiques");
    
    // Obtenez la plage de données (sauter la ligne d'en-tête)
    int lastRow = sheet.Cells.MaxRow;
    int nameColumn = 0; // Supposant que la première colonne contient des noms/catégories
    
    // Ajouter un graphique
    int chartIndex = chartSheet.Charts.Add(ChartType.Column, 2, 2, 20, 10);
    Chart chart = chartSheet.Charts[chartIndex];
    
    // Définir la plage de données pour le graphique
    chart.NSeries.Add($"Sheet1!B2:B{lastRow + 1}", true);
    chart.NSeries.CategoryData = $"Sheet1!A2:A{lastRow + 1}";
    
    // Définir le titre du graphique et d'autres propriétés
    chart.Title.Text = "Analyse des données";
    chart.Legend.Position = LegendPositionType.Bottom;
    
    // Personnalisation supplémentaire du graphique
    chart.NSeries[0].Area.ForegroundColor = Color.FromArgb(79, 129, 189);
    chart.PlotArea.Area.ForegroundColor = Color.White;
    
    // Ajouter des étiquettes de données
    chart.NSeries[0].DataLabels.IsValueShown = true;
    chart.NSeries[0].DataLabels.Position = DataLabelPositionType.OutsideEnd;
}

Étape 8 : Mettre le tout ensemble

Créez le programme principal qui relie tout :

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            // Configurer l'endpoint API
            string baseUrl = "https://api.example.com";
            string endpoint = "/data/endpoint";
            string apiKey = "your-api-key"; // Si nécessaire
            
            // Se connecter à l'API et obtenir des données
            Console.WriteLine("Connexion à l'API...");
            var apiService = new ApiService(baseUrl);
            var jsonData = await apiService.GetApiDataAsync<string>(endpoint, apiKey);
            
            Console.WriteLine("Données récupérées avec succès");
            
            // Générer le rapport Excel
            Console.WriteLine("Génération du rapport Excel...");
            var reportGenerator = new ExcelReportGenerator();
            
            // Option 1 : Conversion directe JSON vers Excel
            string outputPath = "ApiReport_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".xlsx";
            reportGenerator.GenerateReport(jsonData, outputPath);
            
            // Option 2 : Traiter JSON et créer un rapport amélioré
            // var processor = new DataProcessor();
            // var processedData = processor.FlattenJsonData(jsonData);
            // reportGenerator.GenerateReportFromObjects(processedData, outputPath);
            
            Console.WriteLine($"Rapport enregistré à {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Erreur : {ex.Message}");
        }
    }
}

Gestion des différentes structures de réponse API

Les API REST renvoient des données dans divers formats. Voici comment gérer les structures courantes :

1. Tableau d’objets

[
  { "id": 1, "name": "Produit A", "price": 29.99 },
  { "id": 2, "name": "Produit B", "price": 49.99 }
]

Pour cette structure, utilisez :

JsonLayoutOptions options = new JsonLayoutOptions();
options.ArrayAsTable = true;
JsonUtility.ImportData(jsonData, sheet.Cells, 0, 0, options);

2. Objet imbriqué avec tableau de données

{
  "status": "success",
  "data": [
    { "id": 1, "name": "Produit A", "price": 29.99 },
    { "id": 2, "name": "Produit B", "price": 49.99 }
  ]
}

Utilisez la classe DataProcessor pour extraire le tableau “data”, ou :

// Analyser avec Newtonsoft.Json
JObject jsonObj = JObject.Parse(jsonData);
JArray dataArray = (JArray)jsonObj["data"];

// Convertir en chaîne et importer
string dataArrayJson = dataArray.ToString();
JsonUtility.ImportData(dataArrayJson, sheet.Cells, 0, 0, options);

3. Tableaux et objets imbriqués

{
  "categories": [
    {
      "name": "Électronique",
      "products": [
        { "id": 1, "name": "Ordinateur portable", "price": 999.99 },
        { "id": 2, "name": "Téléphone", "price": 699.99 }
      ]
    },
    {
      "name": "Livres",
      "products": [
        { "id": 3, "name": "Roman", "price": 14.99 }
      ]
    }
  ]
}

Pour des structures complexes, créez plusieurs feuilles de calcul :

// Analyser le JSON
JObject root = JObject.Parse(jsonData);
JArray categories = (JArray)root["categories"];

// Créer une feuille de calcul pour chaque catégorie
foreach (var category in categories)
{
    string categoryName = category["name"].ToString();
    Worksheet sheet = workbook.Worksheets.Add(categoryName);
    
    // Obtenez et importez le tableau des produits
    JArray products = (JArray)category["products"];
    JsonUtility.ImportData(products.ToString(), sheet.Cells, 0, 0, options);
}

Passer à la vitesse supérieure : Rapports programmés

Pour automatiser la génération de rapports, ajoutez des capacités de planification :

// Installer le package Task Scheduler
// dotnet add package TaskScheduler

using Microsoft.Win32.TaskScheduler;

public void ScheduleDailyReportGeneration(string appPath)
{
    using (TaskService ts = new TaskService())
    {
        // Créer une nouvelle tâche
        TaskDefinition td = ts.NewTask();
        td.RegistrationInfo.Description = "Génération quotidienne de rapports de données API";
        
        // Créer un déclencheur qui se déclenchera quotidiennement à 7h
        td.Triggers.Add(new DailyTrigger { StartBoundary = DateTime.Today.AddHours(7) });
        
        // Créer une action qui exécutera l'application
        td.Actions.Add(new ExecAction(appPath));
        
        // Enregistrer la tâche dans le dossier racine
        ts.RootFolder.RegisterTaskDefinition("DailyApiReport", td);
    }
}

Fonctionnalités avancées à considérer

Livraison par e-mail - Envoyer automatiquement des rapports par e-mail
Intégration multi-API - Combiner des données provenant de plusieurs API
Rapports basés sur des modèles - Utiliser des modèles Excel pour un branding cohérent
Création de tableaux de bord - Générer des tableaux de bord Excel interactifs
Suivi et rapport d’erreurs - Journaliser les problèmes et faire rapport sur le succès/l’échec

En suivant ce guide, vous avez créé une application C# robuste qui automatise le processus de récupération des données API et de conversion en rapports Excel professionnels, économisant du temps, garantissant l’exactitude et apportant de la valeur commerciale.