Comment générer des fichiers Excel en C# avec IronXL

Pourquoi générer des fichiers 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 10.

Comment générer un fichier Excel en C# avec IronXL: Image 2 - Multiplateforme

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 se traduit par 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. Aucune entrée de registre, aucun enregistrement COM et aucun pack de services Office à gérer. Vos pipelines d'intégration continue fonctionnent sans accroc 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. Néanmoins, cette approche nécessite davantage d'efforts manuels et une connaissance approfondie du schéma XML et de l'installation du kit de développement logiciel Open XML. 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# avec IronXL: Image 3 - Fonctionnalités

Comment installer IronXL dans un projet C# ?

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

Pour installer via la console du gestionnaire de packages ou l'interface de ligne de commande .NET , utilisez l'une des commandes suivantes :

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Vérifiez l'installation à l'aide de ce test simple pour confirmer que la bibliothèque est prête :

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

Si cette opération s'exécute 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 obtenir des instructions d'installation détaillées et des conseils de dépannage, consultez la documentation d'installation officielle de NuGet .

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 création d'un fichier 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 header row
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 header row
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");

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 des versions antérieures. La propriété Metadata vous permet d'intégrer des informations de document qui apparaissent dans les propriétés de fichier Excel, conformément 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 guide sur la création de fichiers Excel .

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 scénario de données lorsque vous écrivez dans un fichier Excel .

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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("EmployeeData.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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("EmployeeData.xlsx");

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 s'affichent correctement sous forme de dates Excel et les booléens apparaissent comme VRAI/FAUX. Cette conversion automatique élimine le code de formatage manuel tout en garantissant l'intégrité des données. Pour les grands ensembles de données, consultez le guide d'importation de données pour découvrir d'autres modèles.

Comment appliquer une mise en forme professionnelle aux fichiers Excel ?

Les fichiers Excel professionnels nécessitent plus que des données brutes. L'API de style d'IronXL transforme les simples feuilles de calcul en documents commerciaux soignés grâce à la mise en forme, aux couleurs et à la hiérarchie visuelle. Vous pouvez appliquer une mise en forme aux cellules pour contrôler chaque aspect visuel de votre feuille de calcul.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

Ce code de formatage crée une apparence professionnelle conforme aux normes du monde des affaires. Les titres en gras avec des couleurs de fond établissent une hiérarchie visuelle. La méthode SetBackgroundColor() accepte les codes de couleur hexadécimaux, offrant un contrôle précis sur votre palette de couleurs. Les propriétés de police incluent les options de taille, de couleur, de gras, d'italique et de soulignement – ​​toutes essentielles pour créer des fichiers Excel conformes aux directives de l'image de marque de l'entreprise.

Le réglage de la largeur des colonnes empêche la troncature du texte. AutoSizeColumn() ajuste automatiquement le contenu, tandis que GetColumn().Width offre un contrôle précis. La mise en forme des nombres utilise les codes de format d'Excel ; par exemple, " $#,##0.00 " affiche les devises 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 la référence des codes de format numérique 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é. 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. Pour en savoir plus sur la fusion de cellules et d'autres fonctionnalités de mise en page, consultez le guide sur la fusion 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.

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

Cet exemple de budget illustre l'application pratique des formules. La propriété Formula accepte la syntaxe standard des formules Excel, en commençant par un 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.

La méthode EvaluateAll() traite toutes les formules, en mettant à jour les valeurs calculées dans tout le classeur. Cela garantit que les formules affichent leurs résultats lorsque le fichier est ouvert dans Excel. Sans évaluation, Excel afficherait le texte de la formule jusqu'à ce que l'utilisateur déclenche un recalcul. Pour en savoir plus sur la lecture des résultats de formules, consultez la documentation sur la lecture des fichiers Excel .

Comment exporter des données de base 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 simplifie ce processus grâce à la prise en charge intégrée de DataTable, éliminant ainsi le besoin de mappage manuel des champs lors de l'exportation d'Excel à partir d'applications C# .

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// 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";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// 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";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

Cet exemple illustre un flux de travail complet allant d'une base de données à Excel. Le DataTable simule la récupération de données de base de données -- en production, remplacez-le par de véritables requêtes de base de données utilisant Entity Framework, Dapper ou 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. Pour travailler avec des ensembles de données et des structures de données plus volumineuses, consultez le guide de conversion Excel vers ensemble de données .

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. Vous pouvez ouvrir et gérer des feuilles de classeur avec seulement quelques lignes de code.

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

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 vue récapitulative. La feuille de synthèse regroupe les indicateurs clés à l'aide de formules transversales. Notez la syntaxe de référence de feuille : " Ventes!B4:B7 " fait référence aux cellules B4 à B7 de la feuille " Ventes ".

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 à toutes les feuilles, maintenant 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 en C# ?

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. Traitez les données par lots plutôt que de charger des ensembles de données entiers en une seule fois. Le modèle suivant permet de maintenir une utilisation prévisible de la mémoire pour les exportations à volume élevé :

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

Pour les applications web, générez les fichiers Excel en mémoire et diffusez-les directement aux utilisateurs plutôt que d'écrire des fichiers temporaires sur le disque. Enveloppez toujours la logique de génération dans une gestion des erreurs afin d'éviter les plantages et de fournir un retour d'information pertinent :

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

Le tableau ci-dessous récapitule les principales bonnes pratiques et indique quand les appliquer :

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 toutes les opérations sur les fichiers temporaires nécessaires. Pour obtenir des conseils de déploiement supplémentaires, consultez la présentation des fonctionnalités IronXL et la documentation complète de l'API .

Où pouvez-vous aller à partir d'ici ?

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, à exporter des données de base de données et à gérer plusieurs feuilles de calcul, le tout sans dépendre de Microsoft Office. Ces techniques fonctionnent de manière cohérente sur les plateformes Windows, Linux et cloud ciblant .NET 10.

Pour aller plus loin, consultez les guides pratiques IronXL pour lire et modifier des fichiers Excel existants, ou la page de licence d'essai pour démarrer en production. Consultez les options de licence qui correspondent aux exigences et à l'envergure de votre projet.