Cum să transformați răspunsurile API în rapoartele Excel în C#

În lumea de astăzi bazată pe date, companiile se bazează în mare măsură pe APIs REST pentru schimbul de date. Cu toate acestea, multe părți interesate preferă să consume aceste date în format Excel pentru analiză și raportare. Acest ghid demonstrează cum să construiască o aplicație completă C# care:

Se conectează la restul APIs
Recuperarea datelor de răspuns JSON
Convertează datele în rapoartele Excel formatate profesional
Ads vizualizare cu diagrame și tabele

Valoarea afacerii

Această soluție oferă o valoare semnificativă prin:

Automatizarea manuală a proceselor de extracție a datelor și de raportare
Asigurarea preciziei datelor prin eliminarea copiilor manuale
Oferirea unui format de rapoarte consecvent
Permite generarea de rapoarte programate

Ghidul de implementare pas cu pas

Pasul 1: Creați o nouă aplicație C#

Începeți prin crearea unei noi aplicații de console:

dotnet new console -n ApiToExcelReporter
cd ApiToExcelReporter

Pasul 2: Instalarea pachetelor necesare

Adăugați pachetele NuGet necesare:

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

Pasul 3: Implementarea clientului REST API

Creați un serviciu pentru comunicarea 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);
        
        // Add authentication if needed
        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($"API call failed: {response.ErrorMessage}");
    }
}

Pasul 4: Procesarea datelor de răspuns JSON

Adăugați o clasă pentru prelucrarea datelor 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);
        
        // Handle different JSON structures
        if (token is JArray array)
        {
            foreach (var item in array)
            {
                results.Add(FlattenObject(item));
            }
        }
        else if (token is JObject obj)
        {
            // For nested data like {"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;
        }
    }
}

Pasul 5: Convertați-vă la Excel cu Aspose.Cells

Implementarea conversiei 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)
    {
        // Create a new workbook
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];
        
        // Configure JSON layout options
        JsonLayoutOptions options = new JsonLayoutOptions
        {
            ArrayAsTable = true,
            ConvertNumericOrDate = true,
            IgnoreNull = true
        };
        
        // Make headers bold
        options.TitleStyle = new CellsFactory().CreateStyle();
        options.TitleStyle.Font.IsBold = true;
        
        // Import JSON data
        JsonUtility.ImportData(jsonData, sheet.Cells, 0, 0, options);
        
        // Auto-fit columns
        sheet.AutoFitColumns();
        
        // Save the workbook
        workbook.Save(outputPath);
    }
    
    public void GenerateReportFromObjects(List<Dictionary<string, object>> data, string outputPath)
    {
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];
        
        // Add headers if there's data
        if (data.Count > 0)
        {
            int col = 0;
            foreach (var key in data[0].Keys)
            {
                // Add header with styling
                Cell cell = sheet.Cells[0, col];
                cell.PutValue(key);
                
                Style style = cell.GetStyle();
                style.Font.IsBold = true;
                cell.SetStyle(style);
                
                col++;
            }
            
            // Add data rows
            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++;
                }
            }
        }
        
        // Format as a table
        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");
        }
        
        // Auto-fit columns
        sheet.AutoFitColumns();
        
        // Save the workbook
        workbook.Save(outputPath);
    }
}

Pasul 6: Adăugați formatul profesional

Îmbunătățiți rezultatul Excel cu stil profesionist:

public void ApplyProfessionalFormatting(Workbook workbook)
{
    Worksheet sheet = workbook.Worksheets[0];
    
    // Create a style for the title
    Style titleStyle = workbook.CreateStyle();
    titleStyle.Font.Size = 14;
    titleStyle.Font.IsBold = true;
    titleStyle.HorizontalAlignment = TextAlignmentType.Center;
    
    // Add a title to the report
    sheet.Cells.Merge(0, 0, 1, sheet.Cells.MaxColumn + 1);
    Cell titleCell = sheet.Cells[0, 0];
    titleCell.PutValue("API Data Report - " + DateTime.Now.ToString("yyyy-MM-dd"));
    titleCell.SetStyle(titleStyle);
    
    // Insert a blank row after the title
    sheet.Cells.InsertRow(1);
    
    // Apply alternating row colors to the data
    Style evenRowStyle = workbook.CreateStyle();
    evenRowStyle.ForegroundColor = Color.FromArgb(240, 240, 240);
    evenRowStyle.Pattern = BackgroundType.Solid;
    
    int dataStartRow = 3; // Accounting for title and blank row
    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);
        }
    }
    
    // Add page header and footer
    sheet.PageSetup.SetHeader(1, "&\"Arial,Bold\"&14API Report");
    sheet.PageSetup.SetFooter(1, "Page &P of &N");
    
    // Set print options
    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;
}

Pasul 7: Adăugați vizualizarea datelor

Îmbunătățiți raportul cu diagrame:

public void AddChartVisualization(Workbook workbook, int dataColumn)
{
    Worksheet sheet = workbook.Worksheets[0];
    Worksheet chartSheet = workbook.Worksheets.Add("Chart Analysis");
    
    // Get the data range (skip header row)
    int lastRow = sheet.Cells.MaxRow;
    int nameColumn = 0; // Assuming first column has names/categories
    
    // Add a chart
    int chartIndex = chartSheet.Charts.Add(ChartType.Column, 2, 2, 20, 10);
    Chart chart = chartSheet.Charts[chartIndex];
    
    // Set the data range for the chart
    chart.NSeries.Add($"Sheet1!B2:B{lastRow + 1}", true);
    chart.NSeries.CategoryData = $"Sheet1!A2:A{lastRow + 1}";
    
    // Set chart title and other properties
    chart.Title.Text = "Data Analysis";
    chart.Legend.Position = LegendPositionType.Bottom;
    
    // Additional chart customization
    chart.NSeries[0].Area.ForegroundColor = Color.FromArgb(79, 129, 189);
    chart.PlotArea.Area.ForegroundColor = Color.White;
    
    // Add data labels
    chart.NSeries[0].DataLabels.IsValueShown = true;
    chart.NSeries[0].DataLabels.Position = DataLabelPositionType.OutsideEnd;
}

Pasul 8: Luați totul împreună

Creați programul principal care leagă totul împreună:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            // Configure API endpoint
            string baseUrl = "https://api.example.com";
            string endpoint = "/data/endpoint";
            string apiKey = "your-api-key"; // If needed
            
            // Connect to API and get data
            Console.WriteLine("Connecting to API...");
            var apiService = new ApiService(baseUrl);
            var jsonData = await apiService.GetApiDataAsync<string>(endpoint, apiKey);
            
            Console.WriteLine("Data retrieved successfully");
            
            // Generate Excel report
            Console.WriteLine("Generating Excel report...");
            var reportGenerator = new ExcelReportGenerator();
            
            // Option 1: Direct JSON to Excel conversion
            string outputPath = "ApiReport_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".xlsx";
            reportGenerator.GenerateReport(jsonData, outputPath);
            
            // Option 2: Process JSON and create enhanced report
            // var processor = new DataProcessor();
            // var processedData = processor.FlattenJsonData(jsonData);
            // reportGenerator.GenerateReportFromObjects(processedData, outputPath);
            
            Console.WriteLine($"Report saved to {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Tratarea diferitelor structuri de răspuns API

REST APIs returnate date în diferite formate. Iată cum să se ocupe de structuri comune:

1 Războiul de obiecte

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

Pentru această structură, utilizați:

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

Obiectul Nested cu array de date

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

Utilizați clasa DataProcessor pentru a extrage aria “data” sau:

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

// Convert to string and import
string dataArrayJson = dataArray.ToString();
JsonUtility.ImportData(dataArrayJson, sheet.Cells, 0, 0, options);

3. obiecte și obiecte nested

{
  "categories": [
    {
      "name": "Electronics",
      "products": [
        { "id": 1, "name": "Laptop", "price": 999.99 },
        { "id": 2, "name": "Phone", "price": 699.99 }
      ]
    },
    {
      "name": "Books",
      "products": [
        { "id": 3, "name": "Novel", "price": 14.99 }
      ]
    }
  ]
}

Pentru structuri complexe, creați mai multe panouri de lucru:

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

// Create a worksheet for each category
foreach (var category in categories)
{
    string categoryName = category["name"].ToString();
    Worksheet sheet = workbook.Worksheets.Add(categoryName);
    
    // Get and import the products array
    JArray products = (JArray)category["products"];
    JsonUtility.ImportData(products.ToString(), sheet.Cells, 0, 0, options);
}

Luați-l la următorul nivel: rapoarte programate

Pentru a automatiza generarea de rapoarte, adăugați abilități de programare:

// Install Task Scheduler package
// dotnet add package TaskScheduler

using Microsoft.Win32.TaskScheduler;

public void ScheduleDailyReportGeneration(string appPath)
{
    using (TaskService ts = new TaskService())
    {
        // Create a new task
        TaskDefinition td = ts.NewTask();
        td.RegistrationInfo.Description = "Daily API Data Report Generation";
        
        // Create a trigger that will fire daily at 7am
        td.Triggers.Add(new DailyTrigger { StartBoundary = DateTime.Today.AddHours(7) });
        
        // Create an action that will run the application
        td.Actions.Add(new ExecAction(appPath));
        
        // Register the task in the root folder
        ts.RootFolder.RegisterTaskDefinition("DailyApiReport", td);
    }
}

Caracteristici avansate de luat în considerare

Distribuție prin e-mail - Trimiteți în mod automat rapoartele prin email
Integrație multi-API - Combinați date din mai multe API
Raporturi bazate pe șablon - Utilizați șabloane Excel pentru branding consistent
Dashboard creation - Generarea de dashboards interactive Excel
Tracking și raportarea erorilor - probleme de înregistrare și rapoarte despre succes / eșec

Urmând acest ghid, ați creat o aplicație robustă C# care automatizează procesul de recuperare a datelor API și convertind-o în rapoartele Excel profesionale - economisirea timpului, asigurarea preciziei și livrarea valorii de afaceri.