IronXL est une puissante bibliothèque C# qui permet aux développeurs de lire, d'écrire et de manipuler des fichiers Excel sans nécessiter l'installation de Microsoft Excel, offrant une compatibilité multiplateforme et prenant en charge des formats tels que XLS, XLSX et CSV grâce à une API intuitive.
IronXL est une bibliothèque robuste pour .NET qui simplifie le travail avec les fichiers Excel. Elle dispose d'une API intuitive qui simplifie la manipulation des documents Excel, prenant en charge différents formats tels que XLS, XLSX et CSV . Cette polyvalence permet une manipulation aisée des valeurs des cellules, des formules et de la mise en forme. IronXL est optimisé pour la performance, capable de gérer efficacement les fichiers volumineux et les opérations de données complexes tout en assurant une utilisation efficace de la mémoire. Sa compatibilité multiplateforme renforce son utilité sur différents systèmes d'exploitation. Voici ses principales caractéristiques et avantages :
Import et Export:
Manipulation des données:
DataSet et DataTable.Style et Formatage:
WorkSheet["A1:B10"].Sécurité:
Compatibilité multiplateforme:
Pour utiliser IronXL dans vos projets .NET, vous devez vous assurer que votre environnement de développement répond aux prérequis suivants:
Vous pouvez installer IronXL via le gestionnaire de packages NuGet dans Visual Studio ou en utilisant la console du gestionnaire de packages avec la commande suivante:
Pour des instructions d'installation plus détaillées, y compris la configuration pour les projets Blazor , .NET MAUI ou VB .NET , reportez-vous à la documentation officielle .
Créons un projet Visual Studio et ajoutons la bibliothèque IronXL pour commencer à travailler sur un fichier Excel.
Ouvrez Microsoft Visual Studio et sélectionnez " Créer un nouveau projet " pour commencer.
Sélectionnez le modèle de projet de votre choix. Ici, nous avons choisi Application console par souci de simplicité.
Entrez maintenant le nom et l'emplacement du projet.
Sélectionnez la version de .NET Framework que vous préférez. Nous avons sélectionné la dernière version disponible sur notre machine.
Une fois que vous aurez cliqué sur le bouton Créer, le projet sera créé et prêt à être utilisé. Ouvrez l'Explorateur de solutions pour vérifier les fichiers du projet.
Maintenant, installons la bibliothèque IronXL à partir du gestionnaire de packages NuGet comme indiqué ci-dessus.
Créons maintenant un fichier Excel sans utiliser la bibliothèque Microsoft Interop. IronXL offre une méthode simple et intuitive pour créer des feuilles de calcul par programmation.
using IronXL;
namespace WorkingWith IronXL
{
public class Program
{
public static void Main()
{
// Create new Excel WorkBook Object
WorkBook workBook = WorkBook.Create();
// Create WorkSheet
WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
// Add data in new worksheet
workSheet["A1"].Value = "IronXL is the best Excel library";
// Save the Excel file as XLSX
workBook.SaveAs("myIronXlDemo.xlsx");
}
}
}Explication du code
WorkBook.Create() pour créer un fichier XLSX.CreateWorkSheet pour créer une feuille de calcul à l'intérieur du classeur.workSheet["A1"].Value.workBook.SaveAs en fournissant un nom de fichier.Fichier Excel de sortie
Contrairement aux approches traditionnelles qui s'appuient sur Microsoft Excel Interop , IronXL est une bibliothèque .NET autonome qui lit et écrit directement les fichiers Excel. Cela signifie : Aucune installation de Microsoft Office requise
IronXL prend en charge l'enregistrement dans plusieurs formats :
// Save as different Excel formats
workBook.SaveAs("file.xlsx"); // Excel 2007+ format
workBook.SaveAs("file.xls"); // Excel 97-2003 format
workBook.SaveAs("file.xlsm"); // Excel with macros
// Export to other formats
workBook.SaveAsCsv("file.csv", ","); // CSV with comma delimiter
workBook.SaveAsJson("file.json"); // JSON format
workBook.SaveAsXml("file.xml"); // XML format' Save as different Excel formats
workBook.SaveAs("file.xlsx") ' Excel 2007+ format
workBook.SaveAs("file.xls") ' Excel 97-2003 format
workBook.SaveAs("file.xlsm") ' Excel with macros
' Export to other formats
workBook.SaveAsCsv("file.csv", ",") ' CSV with comma delimiter
workBook.SaveAsJson("file.json") ' JSON format
workBook.SaveAsXml("file.xml") ' XML formatIronXL assure une gestion complète des erreurs. Voici un exemple de bonne pratique :
try
{
WorkBook workBook = WorkBook.Create();
WorkSheet workSheet = workBook.CreateWorkSheet("Demo");
workSheet["A1"].Value = "Sample Data";
// Check if directory exists
string directory = @"C:\ExcelFiles\";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
workBook.SaveAs(Path.Combine(directory, "output.xlsx"));
}
catch (Exception ex)
{
Console.WriteLine($"Error creating Excel file: {ex.Message}");
}Try
Dim workBook As WorkBook = WorkBook.Create()
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Demo")
workSheet("A1").Value = "Sample Data"
' Check if directory exists
Dim directory As String = "C:\ExcelFiles\"
If Not Directory.Exists(directory) Then
Directory.CreateDirectory(directory)
End If
workBook.SaveAs(Path.Combine(directory, "output.xlsx"))
Catch ex As Exception
Console.WriteLine($"Error creating Excel file: {ex.Message}")
End TryVoyons maintenant comment ajouter des styles aux cellules Excel. IronXL offre des options de style complètes pour créer des feuilles de calcul d'aspect professionnel.
using IronXL;
namespace WorkingWith IronXL
{
public class Program
{
public static void Main()
{
// Create a new workbook
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a new worksheet
WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
// Add multiple values to cells
workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
workSheet["A2"].Value = 999999;
// Apply styles to cells
workSheet["A1"].Style.Font.Bold = true;
workSheet["A1"].Style.Font.Italic = true;
workSheet["A1"].Style.Font.Height = 14;
workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
// Save the workbook
workBook.SaveAs("myIronXlWriteDemo.xlsx");
}
}
}Explication du code
WorkBook.Create.workBook.CreateWorkSheet.workSheet["A1"].Value.workSheet["A1"].Style.Font.Bold.workBook.SaveAs.Fichier Excel de sortie
IronXL propose de nombreuses options de personnalisation, notamment :
Vous pouvez appliquer efficacement des styles à des plages de cellules :
// Apply styles to a range
var range = workSheet["A1:D10"];
foreach (var cell in range)
{
cell.Style.Font.Bold = true;
cell.Style.Font.Color = "#0000FF"; // Blue
cell.Style.SetBackgroundColor("#FFFF00"); // Yellow background
}' Apply styles to a range
Dim range = workSheet("A1:D10")
For Each cell In range
cell.Style.Font.Bold = True
cell.Style.Font.Color = "#0000FF" ' Blue
cell.Style.SetBackgroundColor("#FFFF00") ' Yellow background
NextOui, IronXL prend en charge la mise en forme conditionnelle :
// Add conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(
ComparisonOperator.GreaterThan, "100");
rule.FontFormatting.Bold = true;
rule.FontFormatting.FontColor = "#FF0000"; // Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule);' Add conditional formatting rule
Dim rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.GreaterThan, "100")
rule.FontFormatting.Bold = True
rule.FontFormatting.FontColor = "#FF0000" ' Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule)Voyons maintenant comment lire des fichiers Excel avec IronXL et effectuer des calculs. IronXL prend en charge diverses fonctions mathématiques pour l'analyse des données.
using IronXL;
using System;
namespace WorkingWith IronXL
{
internal class IronXlDemo
{
public static void ReadData()
{
// Load the Excel worksheet
WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
// Select the first worksheet
WorkSheet workSheet = workBook.WorkSheets[0];
// Read a specific cell value
int cellValue = workSheet["A2"].IntValue;
Console.WriteLine($"Value in A2: {cellValue}");
// Read a range of cells
foreach (var cell in workSheet["A1:H10"])
{
Console.Write($"{cell.Text}\t");
if(cell.AddressString.Contains("H"))
{
Console.WriteLine();
}
}
// Calculate aggregate values
decimal sum = workSheet["F2:F10"].Sum();
Console.WriteLine($"Sum of F2:F10: {sum}");
}
}
}Explication du code
WorkBook.Load.Console.WriteLine.Excel d'entrée
Sortie
IronXL prend en charge la lecture de différents types de données à partir des cellules :
// Different ways to read cell values
string textValue = workSheet["A1"].StringValue;
int intValue = workSheet["B1"].IntValue;
decimal decimalValue = workSheet["C1"].DecimalValue;
double doubleValue = workSheet["D1"].DoubleValue;
DateTime dateValue = workSheet["E1"].DateTimeValue;
bool boolValue = workSheet["F1"].BoolValue;
// Read formula results
string formulaResult = workSheet["G1"].FormattedCellValue;' Different ways to read cell values
Dim textValue As String = workSheet("A1").StringValue
Dim intValue As Integer = workSheet("B1").IntValue
Dim decimalValue As Decimal = workSheet("C1").DecimalValue
Dim doubleValue As Double = workSheet("D1").DoubleValue
Dim dateValue As DateTime = workSheet("E1").DateTimeValue
Dim boolValue As Boolean = workSheet("F1").BoolValue
' Read formula results
Dim formulaResult As String = workSheet("G1").FormattedCellValueIronXL propose des solutions sûres pour la manipulation des cellules vides :
// Check if cell is empty
if (workSheet["A1"].IsEmpty)
{
Console.WriteLine("Cell A1 is empty");
}
// Use null-coalescing for safe value reading
string value = workSheet["A1"].StringValue ?? "Default Value";
// Check for specific content types
if (workSheet["B1"].IsNumeric)
{
decimal numValue = workSheet["B1"].DecimalValue;
}' Check if cell is empty
If workSheet("A1").IsEmpty Then
Console.WriteLine("Cell A1 is empty")
End If
' Use null-coalescing for safe value reading
Dim value As String = If(workSheet("A1").StringValue, "Default Value")
' Check for specific content types
If workSheet("B1").IsNumeric Then
Dim numValue As Decimal = workSheet("B1").DecimalValue
End IfIronXL prend en charge diverses fonctions d'agrégation :
// Available aggregate functions
decimal sum = workSheet["A1:A10"].Sum();
decimal avg = workSheet["A1:A10"].Avg();
decimal min = workSheet["A1:A10"].Min();
decimal max = workSheet["A1:A10"].Max();
int count = workSheet["A1:A10"].Count();' Available aggregate functions
Dim sum As Decimal = workSheet("A1:A10").Sum()
Dim avg As Decimal = workSheet("A1:A10").Avg()
Dim min As Decimal = workSheet("A1:A10").Min()
Dim max As Decimal = workSheet("A1:A10").Max()
Dim count As Integer = workSheet("A1:A10").Count()Voyons comment convertir un fichier Excel en HTML pour une utilisation sur le Web. Ceci est particulièrement utile pour afficher des données Excel dans des applications web.
using IronXL;
using IronXL.Options;
namespace WorkingWith IronXL
{
internal class IronXlDemo
{
public static void ConvertToHtml()
{
WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
var options = new HtmlExportOptions()
{
// Set row/column numbers visible in HTML document
OutputRowNumbers = true,
OutputColumnHeaders = true,
// Set hidden rows/columns visible in HTML document
OutputHiddenRows = true,
OutputHiddenColumns = true,
// Set leading spaces as non-breaking
OutputLeadingSpacesAsNonBreaking = true
};
// Export workbook to the HTML file
workBook.ExportToHtml("workBook.html", options);
}
}
}Explication du code
Load.HtmlExportOptions.ExportToHtml pour convertir et enregistrer en HTML.Entrée
Sortie
IronXL propose différentes options d'exportation HTML :
var htmlOptions = new HtmlExportOptions()
{
// Table formatting options
OutputRowNumbers = true,
OutputColumnHeaders = true,
// Visibility options
OutputHiddenRows = false,
OutputHiddenColumns = false,
// Formatting preservation
OutputLeadingSpacesAsNonBreaking = true,
// Custom CSS class
TableCssClass = "excel-table"
};Dim htmlOptions = New HtmlExportOptions() With {
.OutputRowNumbers = True,
.OutputColumnHeaders = True,
.OutputHiddenRows = False,
.OutputHiddenColumns = False,
.OutputLeadingSpacesAsNonBreaking = True,
.TableCssClass = "excel-table"
}IronXL préserve automatiquement la mise en forme de base lors de l'exportation au format HTML . Pour une préservation avancée du formatage :
// Export with inline CSS styles
workBook.ExportToHtml("styled.html", new HtmlExportOptions
{
OutputRowNumbers = false,
OutputColumnHeaders = true,
// Preserves cell styles as inline CSS
PreserveStyles = true
});' Export with inline CSS styles
workBook.ExportToHtml("styled.html", New HtmlExportOptions With {
.OutputRowNumbers = False,
.OutputColumnHeaders = True,
' Preserves cell styles as inline CSS
.PreserveStyles = True
})Oui, vous pouvez exporter des feuilles de calcul individuelles :
// Export specific worksheet
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");
sheet.SaveAsHtml("sheet1.html");
// Export multiple specific sheets
foreach (var sheetName in new[] { "Sheet1", "Sheet3" })
{
workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html");
}' Export specific worksheet
Dim sheet As WorkSheet = workBook.GetWorkSheet("Sheet1")
sheet.SaveAsHtml("sheet1.html")
' Export multiple specific sheets
For Each sheetName As String In {"Sheet1", "Sheet3"}
workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html")
NextIronXL est une bibliothèque .NET polyvalente avec une large gamme d'applications dans le monde réel, notamment:
1. Rapports d'affaires:
2. Analyse de données:
3. Gestion des stocks:
4. Gestion de la relation client (CRM):
5. Établissements d'enseignement:
6. Services financiers :
7. Ressources humaines :
8. Gestion de projet:
9. Commerce électronique :
10. Santé :
Les secteurs qui traitent de grandes quantités de données structurées en tirent le plus grand bénéfice :
IronXL est optimisé pour la performance avec :
Les scénarios d'intégration les plus courants sont les suivants :
IronXL est une bibliothèque Enterprise d' Iron Software. Son fonctionnement nécessite une licence . Vous pouvez télécharger une licence d'essai en utilisant votre adresse e-mail ici . Une fois soumise, la licence vous sera envoyée par courriel. Placez cette licence au début de votre code, avant d'utiliser IronXL:
License.LicenseKey = "your Key Here";License.LicenseKey = "your Key Here"IronXL propose plusieurs types de licences :
Vous pouvez utiliser la clé de licence de plusieurs manières :
// Method 1: In code
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY";
// Method 2: Using app.config or web.config
// Add to configuration file:
// <appSettings>
// <add key="IronXL.LicenseKey" value="YOUR-LICENSE-KEY"/>
// </appSettings>
// Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY");' Method 1: In code
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY"
' Method 2: Using app.config or web.config
' Add to configuration file:
' <appSettings>
' <add key="IronXL.LicenseKey" value="YOUR-LICENSE-KEY"/>
' </appSettings>
' Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY")Pour les applications web, vous pouvez également définir la licence dans le fichier Web.config .
À l'expiration de la période d'essai : Un filigrane apparaît sur les fichiers générés. Certaines fonctionnalités peuvent être limitées.
Pour continuer à utiliser IronXL, achetez une licence commerciale . L'équipe propose des extensions et des mises à niveau de licences pour les clients existants.
IronXL est une puissante bibliothèque .NET permettant de créer, lire et modifier des fichiers Excel, offrant une API intuitive qui simplifie le travail avec les documents Excel. Il prend en charge plusieurs formats, notamment XLS, XLSX et CSV, ce qui le rend polyvalent pour divers cas d'utilisation. IronXL permet une manipulation facile des valeurs de cellules, des formules et du formatage, et est optimisé pour la performance, gérant efficacement les fichiers volumineux et les opérations complexes. Sa gestion de la mémoire garantit des applications réactives, et sa compatibilité multiplateforme en fait un atout précieux pour les développeurs travaillant sur différents systèmes d'exploitation.
Que vous développiez des applications web , des logiciels de bureau ou des services cloud , IronXL fournit les outils nécessaires pour travailler efficacement avec des fichiers Excel en C#. Pour accéder à des fonctionnalités plus avancées, consultez la documentation complète et explorez les nombreux exemples de code .
Points à retenir : Aucune installation de Microsoft Office requise
Restez informé des dernières fonctionnalités et améliorations en consultant le journal des modifications et les étapes clés des améliorations continues d'IronXL.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
