Comment générer un fichier Excel en C# à l'aide d'IronXL.Excel

Pourquoi générer des fichiers de feuilles de calcul Excel sans Microsoft Office ?

Le développement de fonctionnalités de génération Excel sans dépendance à Office résout des problèmes de déploiement critiques. Les environnements serveur disposent rarement de Microsoft Office installé en raison des coûts de licence et de la surcharge en ressources. Chaque installation d'Office nécessite un espace disque et une mémoire considérables, ce qui la rend peu pratique pour les déploiements dans le cloud ou les applications conteneurisées.

IronXL élimine ces contraintes en fonctionnant de manière indépendante. Votre génération de fichiers Excel en C# fonctionne sans modification sous Windows, Linux, macOS, dans les conteneurs Docker ou sur Azure App Services. Cette compatibilité multiplateforme signifie que vous écrivez une seule fois et déployez partout, que ce soit pour des applications .NET Framework, .NET Core ou .NET 8/9.

Comment générer un fichier Excel en C# à l'aide d'IronXL : Image 2 - Cross Platform

Les performances s'améliorent considérablement sans la surcharge liée à l'interopérabilité COM. L'automatisation bureautique traditionnelle crée des instances de processus distinctes pour chaque opération, consommant ainsi de la mémoire et des ressources CPU. IronXL traite tout en mémoire dans l'espace de processus de votre application, ce qui permet une exécution plus rapide et une consommation de ressources réduite lors de la génération de fichiers Excel par programmation.

Le déploiement devient simple puisque IronXL est distribué sous forme d'un seul package NuGet. Sans aucune entrée de registre, sans aucun enregistrement COM et sans aucun service pack Office à maintenir. Vos pipelines d'intégration continue fonctionnent parfaitement et les conteneurs Docker restent légers. Cette approche simplifiée a fait d'IronXL un choix populaire, comme en témoignent divers forums de développeurs où des professionnels partagent leurs expériences en matière d'automatisation Excel.

Certains développeurs explorent encore l'outil de productivité Open XML de Microsoft pour travailler directement avec les structures de fichiers Office Open XML. Cependant, cette approche nécessite plus d'efforts manuels et une connaissance détaillée du schéma XML et de l'installation d'Open XML SDK. IronXL fait abstraction de ces complexités, vous offrant un chemin beaucoup plus rapide pour travailler avec Excel de manière programmatique.

Comment générer un fichier Excel en C# à l'aide d'IronXL : Image 3 - Caractéristiques

Comment installer IronXL dans votre projet C#?

L'installation d'IronXL ne prend que quelques instants via le gestionnaire de paquets NuGet dans l'explorateur de solutions. Dans Visual Studio, cliquez avec le bouton droit sur votre projet et sélectionnez " Gérer les packages NuGet ". Recherchez " IronXL.Excel " et cliquez sur Installer. Le package inclut automatiquement toutes les dépendances nécessaires à la génération de fichiers Excel en C#.

Vous pouvez également utiliser la console du gestionnaire de packages :

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Comment générer un fichier Excel en C# à l'aide d'IronXL : Image 4 - Installation

Pour les utilisateurs de l'interface de ligne de commande .NET travaillant sur des projets C# modernes :

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Vérifiez l'installation à l'aide de ce simple test de création programmatique d'un fichier Excel :

using IronXL;
// Create a new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

using IronXL;
// Create a new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce code crée un objet classeur en mémoire. Si son exécution se déroule sans erreur, IronXL est prêt à l'emploi. La bibliothèque prend en charge toutes les versions modernes de .NET, assurant ainsi la compatibilité avec vos projets existants. Pour des instructions d'installation détaillées et le dépannage, consultez la documentation officielle. Prêt à démarrer ? Téléchargez IronXL dès maintenant et commencez à générer des fichiers Excel en quelques minutes.

Comment créer votre premier fichier Excel ?

La création de fichiers Excel avec IronXL commence par la classe WorkBook, votre passerelle vers toutes les opérations Excel. La bibliothèque prend en charge les formats XLSX modernes et XLS anciens, vous offrant ainsi une grande flexibilité pour répondre à différents besoins lors de la génération de fichiers Excel en C#.

using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");

using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce code illustre plusieurs concepts clés pour la génération de fichiers Excel. La méthode WorkBook.Create() initialise un nouveau fichier Excel en mémoire. Vous spécifiez le format à l'aide de l'énumération ExcelFileFormat - choisissez XLSX pour la compatibilité avec Excel moderne ou XLS pour la prise en charge de l'héritage. La propriété Metadata vous permet d'intégrer des informations de document qui apparaissent dans les propriétés de fichier d'Excel, en adhérant aux normes de propriété de document de Microsoft.

La méthode CreateWorkSheet() ajoute une nouvelle feuille avec le nom spécifié. La notation familière des cellules Excel (A1, B1, etc.) rend la saisie des valeurs intuitive. IronXL gère automatiquement la conversion des types de données, reconnaissant les dates, les nombres et le texte sans conversion explicite. La méthode SaveAs() écrit le fichier Excel complet sur le disque. Pour plus d'informations sur les opérations sur les feuilles de calcul, consultez le tutoriel sur la gestion des feuilles de calcul.

Comment écrire des données dans des cellules Excel ?

IronXL propose plusieurs méthodes pour remplir les cellules Excel, allant de l'affectation individuelle des cellules aux opérations sur des plages de cellules en masse. Comprendre ces méthodes vous aide à choisir l'approche la plus efficace pour votre situation en matière de données.

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("FirstExcelFile.xlsx");

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("FirstExcelFile.xlsx");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Le code illustre la flexibilité d'adressage des cellules d'IronXL. La notation sous forme de chaîne (" A1 ") semble naturelle aux utilisateurs d'Excel, tandis que les indices numériques offrent un contrôle programmatique pour les boucles et la génération dynamique. Les affectations de plage (" B1:B3 ") attribuent efficacement la même valeur à plusieurs cellules, ce qui est idéal pour initialiser des colonnes ou appliquer des valeurs par défaut.

IronXL gère intelligemment différents types de données. Les décimales conservent leur précision pour les données financières, les objets DateTime sont correctement formatés comme des dates Excel et les booléens apparaissent sous la forme VRAI/FAUX. Cette conversion automatique élimine le code de formatage manuel tout en garantissant l'intégrité des données.

// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
    worksheet[$"A{row + 2}"].Value = employees[row].Id;
    worksheet[$"B{row + 2}"].Value = employees[row].Name;
    worksheet[$"C{row + 2}"].Value = employees[row].Department;
    worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}

// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
    worksheet[$"A{row + 2}"].Value = employees[row].Id;
    worksheet[$"B{row + 2}"].Value = employees[row].Name;
    worksheet[$"C{row + 2}"].Value = employees[row].Department;
    worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Comment appliquer une mise en forme professionnelle ?

Les fichiers Excel professionnels nécessitent plus que des données brutes. L'API de stylisme d'IronXL transforme les feuilles de calcul ordinaires en documents commerciaux soignés grâce au formatage, aux couleurs et à la hiérarchie visuelle lorsque vous générez des fichiers Excel en C#.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
dataRange.Style.LeftBorder.Color = "#000000";
dataRange.Style.RightBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
dataRange.Style.LeftBorder.Color = "#000000";
dataRange.Style.RightBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Le réglage de la largeur des colonnes empêche la troncature du texte. AutoSizeColumn() ajuste automatiquement le contenu, tandis que SetColumnWidth() offre un contrôle précis. La mise en forme des nombres utilise les codes de format d'Excel. Par exemple, " $#,##0.00 " affiche la devise avec des séparateurs de milliers et deux décimales. La mise en forme des dates suit des modèles similaires, utilisant les chaînes de format de date Excel standard telles que documentées dans les spécifications Excel de Microsoft .

Les bordures définissent les limites des données, améliorant ainsi leur lisibilité. L'énumération BorderType propose différents styles : fin, moyen, épais, pointillé et tireté. Les options d'alignement centrent les en-têtes et alignent les nombres à droite, conformément aux conventions des feuilles de calcul. L'alternance de couleurs entre les lignes, souvent appelée " lignes à bandes ", aide les lecteurs à suivre les informations dans de vastes ensembles de données. Apprenez-en davantage sur la mise en forme avancée pour créer des données Excel formatées grâce à notre guide de style de cellules.

Comment utiliser les formules Excel par programmation ?

Les formules Excel donnent vie aux feuilles de calcul grâce à des calculs automatiques. IronXL prend en charge la création et l'évaluation de formules, permettant ainsi la mise à jour automatique de feuilles de calcul dynamiques.

var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    // Row total formula
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    // Row total formula
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple de budget illustre l'application pratique des formules. La propriété Formule accepte la syntaxe standard des formules Excel, commençant par le signe égal. IronXL prend en charge les fonctions courantes : SUM, AVERAGE, COUNT, MAX, MIN, et bien d'autres. Les références de cellules dans les formules fonctionnent exactement comme dans Excel, y compris les références relatives et absolues.

Les formules de total de ligne ( =SUM(B{i + 2}:D{i + 2}) ) calculent les totaux trimestriels pour chaque catégorie. L'interpolation de chaînes génère dynamiquement les références de cellules correctes pour chaque ligne. Les totaux mensuels additionnent des colonnes entières, tandis que les calculs de pourcentage divisent des cellules spécifiques par des totaux.

La méthode EvaluateAll() traite toutes les formules, en mettant à jour les valeurs calculées dans l'ensemble du classeur. Cela garantit que les formules affichent leurs résultats lorsqu'elles sont ouvertes dans Excel. Sans évaluation, Excel afficherait les formules jusqu'à ce que l'utilisateur déclenche un nouveau calcul.

Comment exporter des données de bases de données vers Excel ?

Dans la pratique, les applications exportent souvent les données de bases de données vers Excel à des fins de création de rapports et d'analyse. IronXL rationalise ce processus grâce à la prise en charge intégrée de DataTable, ce qui élimine la nécessité de mapper manuellement les champs lors de la génération de fichiers Excel à partir d'applications C#.

using System;
using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    // Sample data (normally from database)
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    // Add total column with formula
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
    reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

using System;
using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    // Sample data (normally from database)
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    // Add total column with formula
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
    reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple complet démontre un flux de travail complet de base de données à Excel pour générer des fichiers Excel en C#. Le DataTable simule la récupération d'une base de données - en production, remplacez-le par vos véritables requêtes de base de données à l'aide d'Entity Framework, de Dapper ou d'ADO.NET. L'approche de mappage manuel offre un contrôle total sur la mise en forme et la disposition, conformément aux bonnes pratiques d'exportation de données recommandées par Microsoft .

Le code génère un rapport professionnel avec un titre, des en-têtes formatés et des lignes de données. Les colonnes de formules calculent dynamiquement les totaux des lignes. La section récapitulative utilise des formules Excel pour compter les commandes et additionner les revenus, garantissant ainsi la mise à jour de ces valeurs en cas de modification des données. La mise en forme des devises et des dates respecte les normes des documents commerciaux, tandis que le dimensionnement automatique des colonnes garantit un affichage correct de tout le contenu. Pour le traitement de grands ensembles de données, consultez notre guide d'optimisation des performances.

Comment gérer plusieurs feuilles de calcul ?

Les fichiers Excel complexes nécessitent souvent plusieurs feuilles de calcul pour organiser les données connexes. IronXL simplifie la gestion de plusieurs feuilles de calcul grâce à des méthodes intuitives pour créer, accéder à et organiser ces feuilles.

// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    // Status based on stock level
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    // Color code status
    if (status == "REORDER")
    {
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
    }
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    // Format headers
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
    var headerRow = sheet["A3:D3"];
    headerRow.Style.Font.Bold = true;
    headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");

// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    // Status based on stock level
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    // Color code status
    if (status == "REORDER")
    {
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
    }
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    // Format headers
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
    var headerRow = sheet["A3:D3"];
    headerRow.Style.Font.Bold = true;
    headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple crée un rapport complet comportant plusieurs feuilles. Chaque feuille de calcul remplit une fonction spécifique : données de vente, suivi des stocks et indicateurs RH. La feuille de synthèse regroupe les indicateurs clés à l'aide de formules transversales. Remarquez la syntaxe de référence de la feuille dans les formules "Sales!B4:B7" fait référence aux cellules B4 à B7 de la feuille Sales.

La fiche d'inventaire illustre la logique conditionnelle, en colorant en rouge les articles en faible stock pour une attention immédiate. La boucle foreach applique une mise en forme cohérente sur toutes les feuilles, conservant ainsi une apparence professionnelle dans l'ensemble du classeur. Dans Excel, les noms des feuilles apparaissent sous forme d'onglets, ce qui permet aux utilisateurs de naviguer facilement entre les différentes vues de données.

Quelles sont les meilleures pratiques pour la génération de fichiers Excel ?

La génération efficace de fichiers Excel en C# nécessite des approches réfléchies en matière d'utilisation de la mémoire, de gestion des erreurs et de déploiement. Ces pratiques garantissent que vos applications évoluent efficacement tout en maintenant leur fiabilité lors de la création de feuilles de calcul Excel par programmation.

La gestion de la mémoire devient cruciale avec les fichiers volumineux. Au lieu de charger des ensembles de données entiers en mémoire, traitez les données par blocs :

// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
    WorkBook workbook = WorkBook.Create();
    WorkSheet sheet = workbook.CreateWorkSheet("Data");
    int rowsPerBatch = 1000;
    int currentRow = 1;
    // Process in batches
    foreach (var batch in GetDataInBatches(rowsPerBatch))
    {
        foreach (var record in batch)
        {
            sheet[$"A{currentRow}"].Value = record.Id;
            sheet[$"B{currentRow}"].Value = record.Name;
            sheet[$"C{currentRow}"].Value = record.Value;
            currentRow++;
        }
    }
    workbook.SaveAs(filename);
}

// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
    WorkBook workbook = WorkBook.Create();
    WorkSheet sheet = workbook.CreateWorkSheet("Data");
    int rowsPerBatch = 1000;
    int currentRow = 1;
    // Process in batches
    foreach (var batch in GetDataInBatches(rowsPerBatch))
    {
        foreach (var record in batch)
        {
            sheet[$"A{currentRow}"].Value = record.Id;
            sheet[$"B{currentRow}"].Value = record.Name;
            sheet[$"C{currentRow}"].Value = record.Value;
            currentRow++;
        }
    }
    workbook.SaveAs(filename);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La gestion des erreurs empêche les plantages de l'application et fournit des informations pertinentes lors de la génération de fichiers Excel :

try
{
    WorkBook workbook = WorkBook.Create();
    // Excel generation code
    workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
    // Log the error
    Console.WriteLine($"Excel generation failed: {ex.Message}");
    // Implement appropriate recovery or notification
}

try
{
    WorkBook workbook = WorkBook.Create();
    // Excel generation code
    workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
    // Log the error
    Console.WriteLine($"Excel generation failed: {ex.Message}");
    // Implement appropriate recovery or notification
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Pour les applications web, générez des fichiers Excel en mémoire et diffusez-les aux utilisateurs :

// ASP.NET Core example
public IActionResult DownloadExcel()
{
    WorkBook workbook = GenerateReport();
    var stream = new MemoryStream();
    workbook.SaveAs(stream);
    stream.Position = 0;
    return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}

// ASP.NET Core example
public IActionResult DownloadExcel()
{
    WorkBook workbook = GenerateReport();
    var stream = new MemoryStream();
    workbook.SaveAs(stream);
    stream.Position = 0;
    return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Les considérations relatives au déploiement garantissent le bon déroulement des opérations de production. IronXL fonctionne dans des environnements restreints sans privilèges élevés, ce qui le rend adapté à l'hébergement mutualisé et aux déploiements conteneurisés. Incluez le fichier de licence IronXL dans votre package de déploiement et assurez-vous que votre application dispose des autorisations d'écriture pour les opérations sur les fichiers temporaires si nécessaire. Pour des conseils de déploiement supplémentaires, consultez la documentation de déploiement.

Conclusion

IronXL transforme la génération de fichiers Excel en C#, un défi complexe, en un codage simple. Vous avez appris à créer des classeurs, à remplir des cellules, à appliquer une mise en forme, à utiliser des formules et à exporter des données de base de données, le tout sans dépendre de Microsoft Office. Ces techniques de génération de fichiers Excel par programmation fonctionnent de manière cohérente sur les plateformes Windows, Linux et cloud.

Prêt à implémenter la génération Excel dans vos applications C# ? Commencez votre essai gratuit ou explorez la documentation de l'interface utilisateur complète pour les fonctionnalités avancées. Pour les déploiements en production, consultez les options de licence qui correspondent aux exigences de votre projet.

Comment générer un fichier Excel en C# à l'aide d'IronXL : Image 11 - Licence