Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Tableur .NET Core
UTILISATION D'IRONXL

Comment créer des feuilles de calcul Excel en C# .NET Core avec IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

La génération programmatique de feuilles de calcul Excel dans ASP.NET Core ouvre de puissantes possibilités d'automatisation, allant des rapports financiers et du suivi des stocks à l'exportation de données et aux tableaux de bord automatisés. Dans le cadre du développement d'applications web, l'intégration de la génération de feuilles de calcul Excel .NET Core améliore l'accessibilité des données et la création de rapports, permettant aux utilisateurs d'interagir avec des ensembles de données complexes et d'en extraire des informations précieuses. Avec IronXL for .NET, les développeurs peuvent créer des fichiers Excel sans installer Microsoft Office ni recourir à Office Interop. Cette bibliothèque multiplateforme fonctionne sous Windows, Linux et macOS, ce qui la rend idéale pour les applications modernes axées sur les données déployées sur Azure ou dans des conteneurs Docker .

Ce tutoriel explique comment créer des feuilles de calcul Excel .NET Core avec un formatage professionnel, des formules et plusieurs options d'exportation. Qu'il s'agisse de développer des applications web ASP.NET Core , des applications console ou des services en arrière-plan, ces techniques s'appliquent à toutes les applications .NET 10. À la fin de cet ouvrage, vous disposerez d'un code fonctionnel permettant de générer des fichiers Excel prêts pour la production, qui s'intègrent aux projets existants dans Visual Studio ou tout environnement de développement .NET .

Comment installer IronXL dans un projet .NET Core ?

Avant de créer des feuilles de calcul, vous devez ajouter IronXL à votre projet. Ouvrez la console du gestionnaire de packages NuGet dans Visual Studio et exécutez l'une de ces commandes :

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

La première commande fonctionne dans la console du gestionnaire de packages de Visual Studio. La seconde fonctionne dans n'importe quel terminal utilisant l'interface de ligne de commande .NET . Les deux installent le même package NuGet et ajoutent automatiquement IronXL aux références de votre projet.

Une fois l'installation terminée, IronXL est prêt à l'emploi avec une simple directive using. La bibliothèque ne nécessite aucune configuration supplémentaire, aucune dépendance d'exécution ni l'installation de Microsoft Office. Il fonctionne sur toutes les plateformes où .NET 10 est exécuté : Windows, Linux, macOS ou tout environnement cloud.

Pour connaître les options d'installation détaillées, y compris le téléchargement manuel des DLL, consultez le guide d'installation IronXL . Les développeurs Linux doivent également consulter la documentation de déploiement Linux pour obtenir des conseils spécifiques à la plateforme.

Feuille de calcul Excel .NET Core : Créez des fichiers de feuilles de calcul Excel Professional en C# avec IronXL for .NET: Image 1 - Installation

Comment créer une feuille de calcul Excel sans dépendre d'Office ?

L'automatisation traditionnelle de Microsoft Excel nécessite l'installation de MS Office et utilise Office Interop, qui ne fonctionne pas sous Linux ni dans les environnements conteneurisés. Comme indiqué dans la documentation de Microsoft sur Office Interop , Office Interop introduit une complexité de déploiement et des problèmes de licences. IronXL for .NET élimine ces limitations en fournissant une solution .NET pure qui traite les fichiers Excel en mode natif avec une prise en charge complète des fonctionnalités des feuilles de calcul modernes.

La bibliothèque prend en charge .NET 8, .NET 9 et .NET 10, ainsi que les versions antérieures de .NET Core. Il gère les formats XLSX, XLS, CSV et d'autres formats de feuilles de calcul sans dépendances externes. Cela le rend particulièrement précieux pour les applications côté serveur, les microservices et les scénarios où l'installation de Microsoft Office n'est pas pratique. L'intégration simplifiée via NuGet vous permet de commencer à écrire des fichiers Excel en quelques minutes :

using IronXL;

// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add an Excel worksheet with a custom name
WorkSheet sheet = workbook.CreateWorkSheet("SalesReport");
// Set a cell value
sheet["A1"].Value = "Product Sales Summary";
// Save the generated Excel file
workbook.SaveAs("SalesReport.xlsx");
using IronXL;

// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add an Excel worksheet with a custom name
WorkSheet sheet = workbook.CreateWorkSheet("SalesReport");
// Set a cell value
sheet["A1"].Value = "Product Sales Summary";
// Save the generated Excel file
workbook.SaveAs("SalesReport.xlsx");
Imports IronXL

' Create a new workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add an Excel worksheet with a custom name
Dim sheet As WorkSheet = workbook.CreateWorkSheet("SalesReport")
' Set a cell value
sheet("A1").Value = "Product Sales Summary"
' Save the generated Excel file
workbook.SaveAs("SalesReport.xlsx")
$vbLabelText   $csharpLabel

La méthode WorkBook.Create() initialise un nouveau classeur Excel, en acceptant un paramètre ExcelFileFormat pour spécifier XLSX (format moderne basé sur XML introduit dans Excel 2007) ou XLS (format binaire hérité). Le format XLSX est recommandé dans la plupart des cas en raison de la taille réduite des fichiers et de la meilleure compatibilité avec les outils modernes. La méthode CreateWorkSheet() ajoute des feuilles de calcul nommées où se trouvent les données Excel -- chaque classeur peut contenir plusieurs feuilles individuelles pour organiser les données connexes.

Les valeurs des cellules sont définies à l'aide d'une notation entre crochets qui reflète le système d'adressage d'Excel -- sheet["A1"] cible directement la cellule A1. Cette syntaxe prend en charge à la fois les cellules spécifiques et les plages de cellules , ce qui simplifie les opérations en masse pour tout projet de feuille de calcul.

Sortie

Feuille de calcul Excel .NET Core : Créez des fichiers de feuilles de calcul Excel Professional en C# avec IronXL for .NET: Image 2 - Sortie Excel

Comment ajouter des feuilles de calcul et y insérer des données par programmation ?

Les feuilles de calcul Excel du monde réel contiennent des données structurées réparties sur plusieurs feuilles de calcul. IronXL fournit des méthodes flexibles pour organiser l'information et remplir efficacement les cellules, que l'on travaille avec une saisie manuelle des données ou des pipelines de données automatisés dans des applications axées sur les données.

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("MonthlySales");

// Set column names as headers
sheet["A1"].Value = "Month";
sheet["B1"].Value = "Revenue";
sheet["C1"].Value = "Units Sold";

// Populate Excel data using a loop (mock sales data)
string[] months = { "January", "February", "March", "April", "May", "June" };
decimal[] revenue = { 45000.50m, 52000.75m, 48500.25m, 61000.00m, 58750.50m, 67200.25m };
int[] units = { 150, 175, 160, 200, 190, 220 };

for (int i = 0; i < months.Length; i++)
{
    int row = i + 2;
    sheet[$"A{row}"].Value = months[i];
    sheet[$"B{row}"].Value = revenue[i];
    sheet[$"C{row}"].Value = units[i];
}

// Set a range of cells to the same value across columns
sheet["D2:D7"].Value = "Active";
workbook.SaveAs("MonthlySales.xlsx");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("MonthlySales");

// Set column names as headers
sheet["A1"].Value = "Month";
sheet["B1"].Value = "Revenue";
sheet["C1"].Value = "Units Sold";

// Populate Excel data using a loop (mock sales data)
string[] months = { "January", "February", "March", "April", "May", "June" };
decimal[] revenue = { 45000.50m, 52000.75m, 48500.25m, 61000.00m, 58750.50m, 67200.25m };
int[] units = { 150, 175, 160, 200, 190, 220 };

for (int i = 0; i < months.Length; i++)
{
    int row = i + 2;
    sheet[$"A{row}"].Value = months[i];
    sheet[$"B{row}"].Value = revenue[i];
    sheet[$"C{row}"].Value = units[i];
}

// Set a range of cells to the same value across columns
sheet["D2:D7"].Value = "Active";
workbook.SaveAs("MonthlySales.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("MonthlySales")

' Set column names as headers
sheet("A1").Value = "Month"
sheet("B1").Value = "Revenue"
sheet("C1").Value = "Units Sold"

' Populate Excel data using a loop (mock sales data)
Dim months As String() = {"January", "February", "March", "April", "May", "June"}
Dim revenue As Decimal() = {45000.5D, 52000.75D, 48500.25D, 61000.0D, 58750.5D, 67200.25D}
Dim units As Integer() = {150, 175, 160, 200, 190, 220}

For i As Integer = 0 To months.Length - 1
    Dim row As Integer = i + 2
    sheet($"A{row}").Value = months(i)
    sheet($"B{row}").Value = revenue(i)
    sheet($"C{row}").Value = units(i)
Next

' Set a range of cells to the same value across columns
sheet("D2:D7").Value = "Active"
workbook.SaveAs("MonthlySales.xlsx")
$vbLabelText   $csharpLabel

L'interpolation de chaînes ($"A{row}") permet un adressage dynamique des cellules dans les boucles, ce qui facilite le remplissage programmatique des lignes à partir de n'importe quelle source de données. La syntaxe de plage sheet["D2:D7"] applique des valeurs à plusieurs cellules simultanément -- utile pour les colonnes d'état, les valeurs par défaut ou l'initialisation des régions de données. IronXL gère automatiquement la conversion des types de données, stockant les décimales sous forme de valeurs numériques et le contenu de chaîne sous forme de texte tout en préservant les types de données Excel appropriés pour le fichier généré.

Travailler avec plusieurs feuilles de travail

La création de plusieurs feuilles de calcul permet d'organiser logiquement les données Excel connexes au sein d'un seul et même classeur :

WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
WorkSheet detailSheet = workbook.CreateWorkSheet("Details");
WorkSheet archiveSheet = workbook.CreateWorkSheet("Archive");
WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
WorkSheet detailSheet = workbook.CreateWorkSheet("Details");
WorkSheet archiveSheet = workbook.CreateWorkSheet("Archive");
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detailSheet As WorkSheet = workbook.CreateWorkSheet("Details")
Dim archiveSheet As WorkSheet = workbook.CreateWorkSheet("Archive")
$vbLabelText   $csharpLabel

Pour les applications nécessitant une intégration de base de données, IronXL fonctionne avec Entity Framework Core, Dapper ou ADO .NET brut. Les données issues des objets DataTable peuvent être exportées directement vers des feuilles de calcul , ce qui simplifie les flux de travail de reporting et permet aux utilisateurs de partager des données entre différents systèmes.

Pour en savoir plus sur la gestion des feuilles de calcul et l'écriture de fichiers Excel, consultez la documentation. Pour lire un fichier Excel existant, consultez le tutoriel sur le chargement des fichiers Excel .

Sortie

Feuille de calcul Excel .NET Core : Créer des fichiers de feuilles de calcul Excel Professional en C# avec IronXL: Image 3 - Sortie de plusieurs feuilles de calcul

Comment appliquer une mise en forme et un style Professional ?

Les données brutes prennent tout leur sens lorsqu'elles sont correctement formatées. IronXL prend en charge les couleurs d'arrière-plan, les polices, les bordures et les formats numériques – des fonctionnalités de mise en forme essentielles qui transforment les feuilles de calcul Excel en rapports soignés, adaptés aux présentations de direction ou aux livrables clients.

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("FormattedReport");

// Create headers with styling
sheet["A1"].Value = "Category";
sheet["B1"].Value = "Amount";
sheet["C1"].Value = "Date";

// Apply header formatting to the Excel sheet
sheet["A1:C1"].Style.SetBackgroundColor("#2E86AB");
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.Font.SetColor("#FFFFFF");

// Add sample data to specific cells
sheet["A2"].Value = "Software License";
sheet["B2"].Value = 1299.99m;
sheet["C2"].Value = DateTime.Now;

// Format currency and date columns
sheet["B2"].FormatString = "$#,##0.00";
sheet["C2"].FormatString = "yyyy-MM-dd";

// Add borders around the data range
var dataRange = sheet["A1:C2"];
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("FormattedReport.xlsx");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("FormattedReport");

// Create headers with styling
sheet["A1"].Value = "Category";
sheet["B1"].Value = "Amount";
sheet["C1"].Value = "Date";

// Apply header formatting to the Excel sheet
sheet["A1:C1"].Style.SetBackgroundColor("#2E86AB");
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.Font.SetColor("#FFFFFF");

// Add sample data to specific cells
sheet["A2"].Value = "Software License";
sheet["B2"].Value = 1299.99m;
sheet["C2"].Value = DateTime.Now;

// Format currency and date columns
sheet["B2"].FormatString = "$#,##0.00";
sheet["C2"].FormatString = "yyyy-MM-dd";

// Add borders around the data range
var dataRange = sheet["A1:C2"];
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("FormattedReport.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("FormattedReport")

' Create headers with styling
sheet("A1").Value = "Category"
sheet("B1").Value = "Amount"
sheet("C1").Value = "Date"

' Apply header formatting to the Excel sheet
sheet("A1:C1").Style.SetBackgroundColor("#2E86AB")
sheet("A1:C1").Style.Font.Bold = True
sheet("A1:C1").Style.Font.SetColor("#FFFFFF")

' Add sample data to specific cells
sheet("A2").Value = "Software License"
sheet("B2").Value = 1299.99D
sheet("C2").Value = DateTime.Now

' Format currency and date columns
sheet("B2").FormatString = "$#,##0.00"
sheet("C2").FormatString = "yyyy-MM-dd"

' Add borders around the data range
Dim dataRange = sheet("A1:C2")
dataRange.Style.BottomBorder.SetColor("#000000")
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin
workbook.SaveAs("FormattedReport.xlsx")
$vbLabelText   $csharpLabel

La propriété Style expose des options de mise en forme correspondant aux capacités de Microsoft Excel. Les couleurs d'arrière-plan acceptent les codes hexadécimaux (avec ou sans le préfixe #), tandis que FormatString applique des formats numériques identiques à la syntaxe de formatage personnalisée d'Excel -- les mêmes modèles fonctionnent dans les deux environnements. Les styles de bordure prennent en charge les types Fin, Moyen, Épais et Double, permettant un contrôle précis des limites des cellules dans votre feuille de calcul Excel.

Techniques de mise en forme avancées

Pour les feuilles de calcul Excel contenant de nombreuses données, CreateFreezePane(0, 1) conserve les en-têtes visibles lors du défilement - une amélioration subtile qui améliore considérablement l'utilisabilité pour les grands ensembles de données. La configuration d'impression via sheet.PrintSetup gère l'orientation, les marges et la mise à l'échelle pour la sortie physique.

Explorez les options de style supplémentaires dans le guide de mise en forme des cellules et le tutoriel sur la configuration des bordures . Ces outils vous offrent un contrôle total sur chaque aspect de l'apparence des cellules.

Comment utiliser les formules Excel pour les calculs automatiques ?

Le moteur de calcul d'Excel automatise l'analyse des données, et IronXL prend entièrement en charge les formules. Définissez les formules sous forme de chaînes de caractères en utilisant la syntaxe Excel standard, et IronXL calcule automatiquement les résultats sur demande – un élément essentiel pour les rapports et l'analyse financière.

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("BudgetCalculations");

// Add expense data to the Excel workbook
sheet["A1"].Value = "Expense";
sheet["B1"].Value = "Amount";
sheet["A2"].Value = "Rent";
sheet["B2"].Value = 2500;
sheet["A3"].Value = "Utilities";
sheet["B3"].Value = 350;
sheet["A4"].Value = "Supplies";
sheet["B4"].Value = 875;
sheet["A5"].Value = "Marketing";
sheet["B5"].Value = 1200;

// Add formulas for calculations
sheet["A7"].Value = "Total:";
sheet["B7"].Formula = "=SUM(B2:B5)";
sheet["A8"].Value = "Average:";
sheet["B8"].Formula = "=AVERAGE(B2:B5)";
sheet["A9"].Value = "Maximum:";
sheet["B9"].Formula = "=MAX(B2:B5)";
sheet["A10"].Value = "Count:";
sheet["B10"].Formula = "=COUNT(B2:B5)";

// Calculate all formulas
workbook.EvaluateAll();

// Access calculated values programmatically
decimal total = sheet["B7"].DecimalValue;
Console.WriteLine($"Calculated total: {total}");
workbook.SaveAs("BudgetCalculations.xlsx");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("BudgetCalculations");

// Add expense data to the Excel workbook
sheet["A1"].Value = "Expense";
sheet["B1"].Value = "Amount";
sheet["A2"].Value = "Rent";
sheet["B2"].Value = 2500;
sheet["A3"].Value = "Utilities";
sheet["B3"].Value = 350;
sheet["A4"].Value = "Supplies";
sheet["B4"].Value = 875;
sheet["A5"].Value = "Marketing";
sheet["B5"].Value = 1200;

// Add formulas for calculations
sheet["A7"].Value = "Total:";
sheet["B7"].Formula = "=SUM(B2:B5)";
sheet["A8"].Value = "Average:";
sheet["B8"].Formula = "=AVERAGE(B2:B5)";
sheet["A9"].Value = "Maximum:";
sheet["B9"].Formula = "=MAX(B2:B5)";
sheet["A10"].Value = "Count:";
sheet["B10"].Formula = "=COUNT(B2:B5)";

// Calculate all formulas
workbook.EvaluateAll();

// Access calculated values programmatically
decimal total = sheet["B7"].DecimalValue;
Console.WriteLine($"Calculated total: {total}");
workbook.SaveAs("BudgetCalculations.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("BudgetCalculations")

' Add expense data to the Excel workbook
sheet("A1").Value = "Expense"
sheet("B1").Value = "Amount"
sheet("A2").Value = "Rent"
sheet("B2").Value = 2500
sheet("A3").Value = "Utilities"
sheet("B3").Value = 350
sheet("A4").Value = "Supplies"
sheet("B4").Value = 875
sheet("A5").Value = "Marketing"
sheet("B5").Value = 1200

' Add formulas for calculations
sheet("A7").Value = "Total:"
sheet("B7").Formula = "=SUM(B2:B5)"
sheet("A8").Value = "Average:"
sheet("B8").Formula = "=AVERAGE(B2:B5)"
sheet("A9").Value = "Maximum:"
sheet("B9").Formula = "=MAX(B2:B5)"
sheet("A10").Value = "Count:"
sheet("B10").Formula = "=COUNT(B2:B5)"

' Calculate all formulas
workbook.EvaluateAll()

' Access calculated values programmatically
Dim total As Decimal = sheet("B7").DecimalValue
Console.WriteLine($"Calculated total: {total}")
workbook.SaveAs("BudgetCalculations.xlsx")
$vbLabelText   $csharpLabel

La propriété Formula accepte la syntaxe standard des formules Excel -- les mêmes formules qui fonctionnent dans Microsoft Excel fonctionnent ici. Après avoir défini les formules, appelez EvaluateAll() pour calculer les résultats. Cette étape garantit que les valeurs calculées sont immédiatement disponibles via des propriétés typées comme DecimalValue, IntValue ou StringValue. Sans appeler EvaluateAll(), les formules s'enregistrent toujours correctement et se calculent lorsqu'elles sont ouvertes dans Excel, mais l'accès programmatique aux résultats nécessite d'abord une évaluation.

Sortie

Feuille de calcul Excel .NET Core : Créer des fichiers de feuilles de calcul Excel Professional en C# avec IronXL: Image 4 - Résultat des formules Excel

Feuille de calcul Excel .NET Core : Créer des fichiers de feuilles de calcul Excel Professional en C# avec IronXL: Image 5 - Sortie console

IronXL prend en charge plus de 150 fonctions Excel, notamment les opérations mathématiques (SOMME, MOYENNE, ROND), les fonctions statistiques (COMPTE, MAX, MIN, STDEV), la manipulation de texte (CONCATENER, GAUCHE, DROITE) et les opérations logiques (IF, AND, OR). Consultez le guide de modification des formules pour les scénarios avancés, notamment les références de cellules entre feuilles de calcul.

Méthodes d'agrégation intégrées

Pour les scénarios plus simples où les formules n'ont pas besoin d'être conservées dans le fichier Excel, IronXL propose des méthodes d'agrégation intégrées :

decimal sum = sheet["B2:B5"].Sum();
decimal avg = sheet["B2:B5"].Avg();
decimal max = sheet["B2:B5"].Max();
decimal sum = sheet["B2:B5"].Sum();
decimal avg = sheet["B2:B5"].Avg();
decimal max = sheet["B2:B5"].Max();
Dim sum As Decimal = sheet("B2:B5").Sum()
Dim avg As Decimal = sheet("B2:B5").Avg()
Dim max As Decimal = sheet("B2:B5").Max()
$vbLabelText   $csharpLabel

Ces méthodes offrent une alternative native C# lorsque les calculs n'ont pas besoin d'apparaître sous forme de formules visibles dans la feuille de calcul. L'API orientée objet garantit la lisibilité et la sécurité des types de votre code sans nécessiter de syntaxe de formule basée sur des chaînes de caractères.

Comment exporter des fichiers Excel et les mettre à disposition pour téléchargement ?

IronXL prend en charge plusieurs formats d'exportation pour répondre aux différentes exigences d'intégration. Outre les formats Excel standard, les feuilles de calcul peuvent être exportées au format CSV pour l'échange de données, au format JSON pour les applications web ou au format TSV pour la compatibilité avec les systèmes existants. Cette flexibilité permet d'intégrer facilement la génération d'Excel dans n'importe quel flux de travail.

using IronXL;

WorkBook workbook = WorkBook.Load("BudgetCalculations.xlsx");

// Export to different formats
workbook.SaveAs("output.xlsx");      // Modern Excel (Office 2007+)
workbook.SaveAs("output.xls");       // Legacy Excel (97-2003)
workbook.SaveAsCsv("output.csv");    // CSV for data import/export
workbook.SaveAsJson("output.json");  // JSON for web APIs
using IronXL;

WorkBook workbook = WorkBook.Load("BudgetCalculations.xlsx");

// Export to different formats
workbook.SaveAs("output.xlsx");      // Modern Excel (Office 2007+)
workbook.SaveAs("output.xls");       // Legacy Excel (97-2003)
workbook.SaveAsCsv("output.csv");    // CSV for data import/export
workbook.SaveAsJson("output.json");  // JSON for web APIs
Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("BudgetCalculations.xlsx")

' Export to different formats
workbook.SaveAs("output.xlsx")      ' Modern Excel (Office 2007+)
workbook.SaveAs("output.xls")       ' Legacy Excel (97-2003)
workbook.SaveAsCsv("output.csv")    ' CSV for data import/export
workbook.SaveAsJson("output.json")  ' JSON for web APIs
$vbLabelText   $csharpLabel

Chaque format répond à des cas d'utilisation spécifiques. XLSX est la meilleure solution pour préserver le formatage et les formules lors du partage avec les utilisateurs d'Excel. Le format CSV offre une compatibilité maximale pour l'importation dans des bases de données, des outils d'analyse ou d'autres tableurs. JSON s'intègre naturellement aux interfaces JavaScript et aux API REST.

Sortie

Feuille de calcul Excel .NET Core : Créer des fichiers de feuilles de calcul Excel Professional en C# avec IronXL: Image 6 - Sortie Excel moderne

Feuille de calcul Excel .NET Core : Créer des fichiers de feuilles de calcul Excel Professional en C# avec IronXL: Image 7 - Sortie JSON

Servir des fichiers Excel dans ASP.NET Core

Pour les applications web ASP.NET Core, servir des fichiers Excel sous forme de réponses téléchargeables ne nécessite que quelques lignes de code :

[HttpGet("download-report")]
public IActionResult DownloadReport()
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workbook.CreateWorkSheet("Report");
    sheet["A1"].Value = "Generated Report";
    sheet["A2"].Value = DateTime.Now;

    var stream = workbook.ToStream();
    return File(
        stream,
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "Report.xlsx"
    );
}
[HttpGet("download-report")]
public IActionResult DownloadReport()
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workbook.CreateWorkSheet("Report");
    sheet["A1"].Value = "Generated Report";
    sheet["A2"].Value = DateTime.Now;

    var stream = workbook.ToStream();
    return File(
        stream,
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "Report.xlsx"
    );
}
Imports Microsoft.AspNetCore.Mvc

<HttpGet("download-report")>
Public Function DownloadReport() As IActionResult
    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
    sheet("A1").Value = "Generated Report"
    sheet("A2").Value = DateTime.Now

    Dim stream = workbook.ToStream()
    Return File(
        stream,
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "Report.xlsx"
    )
End Function
$vbLabelText   $csharpLabel

La méthode ToStream() crée un MemoryStream contenant le fichier Excel complet, que la méthode File() d' ASP.NET Core renvoie avec le type MIME approprié. Ce modèle fonctionne de la même manière pour les contrôleurs MVC, les contrôleurs API et les API minimales. Le navigateur déclenche automatiquement un téléchargement de fichier avec le nom de fichier spécifié, ce qui permet aux utilisateurs d'enregistrer localement le fichier Excel généré.

Pour les applications à fort trafic, envisagez de générer des rapports de manière asynchrone et de mettre en cache les résultats lorsque les données sous-jacentes ne changent pas fréquemment ; cette approche améliore considérablement les performances. La documentation relative à la conversion de format couvre des scénarios d'exportation supplémentaires, notamment les fichiers protégés par mot de passe.

Comment IronXL se compare-t-il aux autres bibliothèques Excel .NET ?

Il existe plusieurs bibliothèques pour la manipulation d'Excel en .NET, chacune présentant des atouts différents. Le tableau ci-dessous présente une comparaison de leurs performances selon les critères les plus importants pour les applications de production :

Comparaison des bibliothèques Excel .NET pour le développement .NET Core
Caractéristique IronXL Alternatives open source
Installation de Microsoft Office requise Non Non
Support Technique Oui (équipe d'ingénierie disponible 24h/24 et 5j/7) communautaire
Multiplateforme (.NET Core) Prise en charge complète Cela varie selon la bibliothèque
Moteur de calcul de formules Plus de 150 fonctions Limité ou aucun
Modèle de licence Publicité avec essai gratuit Divers logiciels libres

IronXL excelle dans les scénarios Enterprise exigeant un support technique fiable, une documentation complète et des mises à jour régulières. La bibliothèque gère avec élégance les cas particuliers — fichiers corrompus, formules complexes et grands ensembles de données — là où les alternatives open source peuvent avoir des difficultés. Pour les équipes qui privilégient la rapidité de développement et la fiabilité de la production, le soutien commercial d'IronXL est un gage de tranquillité d'esprit.

Selon les discussions sur Stack Overflow, les développeurs citent fréquemment la simplicité de l'API et la qualité de la documentation comme facteurs décisifs lorsqu'ils choisissent des bibliothèques Excel pour leurs projets .NET Core. La Fondation .NET souligne également que le déploiement multiplateforme est une priorité pour le développement .NET moderne, ce qui rend les bibliothèques indépendantes d'Office essentielles pour des solutions maintenables.

Pour les équipes soucieuses de la sécurité : IronXL fonctionne indépendamment de Microsoft Office et évite l'interopérabilité avec Office, ce qui minimise le risque de vulnérabilités externes. La prise en charge intégrée du chiffrement et de la protection par mot de passe vous permet de sécuriser les fichiers Excel générés, garantissant ainsi que seuls les utilisateurs autorisés peuvent accéder aux feuilles de calcul et aux données critiques ou les modifier. Consultez les options de licence IronXL pour trouver le forfait qui convient à votre équipe.

Comment gérer les performances à grande échelle ?

Lorsque votre application génère des fichiers Excel pour de nombreux utilisateurs simultanés ou traite de grands ensembles de données, la planification des performances devient essentielle. IronXL gère efficacement les classeurs volumineux car il fonctionne entièrement en mémoire sans créer de processus Office ni d'objets COM. Cette architecture permet de rendre prévisible la surcharge du processeur et de la mémoire.

Stratégies clés de performance

Pour les rapports contenant de nombreuses données, remplissez les cellules en bloc plutôt qu'une par une. L'écriture dans une plage à l'aide de la notation entre crochets sheet["A1:Z1000"] peut être nettement plus rapide que le parcours des cellules individuelles lors de la définition de valeurs uniformes. Pour les données hétérogènes, utilisez des boucles avec interpolation de chaînes pour l'adressage dynamique des cellules.

Pour les points de terminaison ASP.NET Core qui génèrent des rapports à la demande, envisagez de mettre en cache les tableaux d'octets résultants ou la sortie MemoryStream à l'aide de IMemoryCache ou d'un cache distribué comme Redis. Lorsque les données sous-jacentes ne changent pas entre les requêtes, les fichiers Excel mis en cache peuvent être renvoyés immédiatement sans régénération. Cette stratégie est particulièrement efficace pour les exportations de tableaux de bord et les rapports programmés.

La génération multithread est sûre avec IronXL lorsque chaque thread fonctionne sur sa propre instance WorkBook. Évitez de partager des instances de classeur ou de feuille de calcul entre plusieurs threads sans synchronisation. Pour le traitement des tâches en arrière-plan, des bibliothèques comme Hangfire ou Quartz .NET fonctionnent de concert avec IronXL pour la génération de rapports planifiés, vous permettant de pré-générer des fichiers pendant les heures creuses.

Pour les ensembles de données les plus volumineux, envisagez de répartir les données sur plusieurs feuilles de calcul plutôt que de créer des feuilles uniques contenant des dizaines de milliers de lignes. La documentation relative à l'exportation de DataTable présente des modèles efficaces pour le transfert de données en masse à partir de sources .NET . Des exemples de code supplémentaires couvrant des scénarios avancés tels que la lecture de fichiers Excel existants ou l'utilisation de classeurs protégés par mot de passe sont disponibles dans la documentation complète de l'API .

Quelles sont vos prochaines étapes ?

La création de feuilles de calcul Excel .NET Core avec IronXL transforme une tâche autrefois complexe en une opération .NET simple. De la manipulation de base des cellules aux calculs de formules et à la mise en forme Professional , la bibliothèque fournit une boîte à outils complète pour l'automatisation des feuilles de calcul qui fonctionne partout où .NET 10 est exécuté : serveurs Windows, conteneurs Linux ou plateformes cloud.

L'architecture multiplateforme garantit un comportement identique sur les machines de développement et les environnements de production, éliminant ainsi les problèmes de "fonctionne sur ma machine", fréquents avec les solutions Office Interop. Commencez par la commande d'installation NuGet , créez votre premier classeur et développez-le à partir de là en utilisant les modèles présentés tout au long de ce guide.

Téléchargez une version d'essai gratuite de 30 jours pour découvrir toutes les fonctionnalités sans aucune limitation, ou consultez les options de licence pour un déploiement en production. Parcourez les exemples de code IronXL pour découvrir d'autres scénarios en action et consultez le centre de documentation IronXL pour obtenir la référence API complète et les guides de configuration avancée.

Questions Fréquemment Posées

Quels sont les avantages de l'utilisation d'IronXL pour la génération de feuilles de calcul Excel dans .NET Core ?

IronXL permet aux développeurs de créer des fichiers Excel de manière programmatique sans avoir besoin de Microsoft Office ou d'Office Interop, offrant une compatibilité multiplateforme sur Windows, Linux et macOS. Il s'agit donc d'un outil idéal pour les applications modernes axées sur les données.

IronXL peut-il être utilisé dans les applications ASP.NET Core ?

Oui, IronXL for .NET peut être intégré dans des applications ASP.NET Core, offrant ainsi de puissantes possibilités d'automatisation telles que la création de rapports financiers, le suivi des stocks et l'exportation de données.

Est-il possible de générer des feuilles de calcul Excel dans des applications web à l'aide d'IronXL.Excel ?

Oui. IronXL prend en charge la génération et le téléchargement de feuilles Excel dans les applications web, améliorant ainsi l'expérience utilisateur en permettant l'exportation et l'interaction avec des tableaux de données complexes.

IronXL nécessite-t-il l'installation de Microsoft Office ?

Non, IronXL ne nécessite pas l'installation de Microsoft Office. Il fonctionne indépendamment d'Office Interop, ce qui simplifie le déploiement et l'intégration.

Comment IronXL améliore-t-il l'accessibilité des données dans les applications .NET Core ?

IronXL améliore l'accessibilité des données en permettant aux développeurs de générer par programme des feuilles de calcul Excel, ce qui facilite l'interaction avec les utilisateurs et l'extraction d'informations à partir d'ensembles de données complexes.

IronXL peut-il être déployé dans des environnements en nuage comme Azure ?

Oui, IronXL peut être déployé dans des environnements cloud tels qu'Azure et les conteneurs Docker, ce qui le rend adapté aux applications évolutives basées sur le cloud.

IronXL est-il compatible avec macOS et Linux ?

IronXL est entièrement compatible avec macOS et Linux, fournissant une solution multiplateforme pour la génération de feuilles de calcul Excel dans les applications .NET.

Quels types d'applications bénéficient de l'utilisation d'IronXL ?

Les applications qui nécessitent des solutions axées sur les données, telles que les rapports financiers, la gestion des stocks et les tableaux de bord automatisés, bénéficient grandement de l'utilisation d'IronXL pour la génération de feuilles de calcul Excel.

Comment IronXL améliore-t-il l'expérience utilisateur dans les applications web ?

IronXL améliore l'expérience utilisateur en permettant l'exportation de tableaux de données complexes dans des feuilles de calcul Excel, ce qui rend les données plus accessibles et portables pour les utilisateurs finaux.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes
Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi