Comment travailler avec des fichiers Excel en C# : Figure 1 - Tutoriel

Comment puis-je travailler avec un classeur Excel en C# ?

1. Créez un projet Visual Studio et ajoutez le package NuGet IronXL.
2. Créez un fichier Excel sans Interop.
3. Ajoutez du style au fichier Excel en utilisant IronXL.
4. Lisez les valeurs d'Excel et calculez.
5. Convertissez Excel en HTML pour une utilisation sur le web.

Qu'est-ce que la bibliothèque IronXL ?

IronXL est une bibliothèque robuste for .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 :

Quelles sont les principales caractéristiques d' IronXL?

1. Import et Export:

   • Importer des données : Prend en charge les formats XLS, XLSX, CSV et TSV .
   • Exportation des données : Possibilité d'exporter les feuilles de calcul aux formats XLS, XLSX, CSV, TSV et JSON.

2. Manipulation des données:

   • Intégration System.Data : Travaillez avec des feuilles de calcul en tant qu'objets DataSet et DataTable .
   • Formules : Prend en charge les formules Excel qui se recalculent lorsque les feuilles sont modifiées.

3. Style et Formatage:

   • Style des cellules : Personnalisez la police, la taille , le motif d'arrière-plan , la bordure, l'alignement et les formats numériques .
   • Plages : Définition intuitive des plages avec la syntaxe WorkSheet["A1:B10"].

4. Sécurité:

   • Chiffrement : Chiffrer et déchiffrer les fichiers XLSX, XLSM et XLTX avec des mots de passe.
5. Compatibilité multiplateforme:
   • Fonctionne avec .NET Framework, .NET Core, .NET Standard et Azure .
   • Compatible avec Windows, macOS , Linux , Docker et AWS .

Pourquoi choisir IronXL plutôt que d'autres bibliothèques Excel ?

1. Pas besoin de Microsoft Office : IronXL ne nécessite pas l'installation de Microsoft Office, ce qui le rend léger et facile à déployer.
2. Facilité d'utilisation : L'API est intuitive et facile à utiliser, permettant aux développeurs d'intégrer rapidement les fonctionnalités d'Excel dans leurs applications.
3. Performances : IronXL est optimisé pour les performances, assurant un traitement rapide et efficace des fichiers Excel volumineux.
4. Polyvalence : Convient à une large gamme d'applications, y compris les solutions web, de bureau et basées sur le cloud.
5. Documentation complète : Une documentation et des exemples exhaustifs sont disponibles, facilitant la prise en main par les développeurs et la recherche de solutions aux problèmes courants.

Comment débuter avec IronXL?

Pour utiliser IronXL dans vos projets .NET, vous devez vous assurer que votre environnement de développement répond aux prérequis suivants:

dotnet add package IronXL.Excel --version 2024.8.5

dotnet add package IronXL.Excel --version 2024.8.5

Comment créer mon premier fichier Excel avec IronXL?

Créons un projet Visual Studio et ajoutons la bibliothèque IronXL pour commencer à travailler sur un fichier Excel.

Comment créer un projet Visual Studio et y ajouter IronXL?

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.

Comment créer un fichier Excel sans interopérabilité ?

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 WorkingWithIronXL
{
    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");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    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");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create new Excel WorkBook Object
			Dim workBook As WorkBook = WorkBook.Create()
			' Create WorkSheet
			Dim workSheet As 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")
		End Sub
	End Class
End Namespace

Explication du code

1. Nous ajoutons l'espace de noms IronXL pour commencer à travailler avec la bibliothèque.
2. Créez un objet Excel avec WorkBook.Create() pour créer un fichier XLSX.
3. Appelez la méthode CreateWorkSheet pour créer une feuille de calcul à l'intérieur du classeur.
4. Ajoutez des valeurs aux cellules en utilisant workSheet["A1"].Value.
5. Enregistrez le fichier Excel en utilisant workBook.SaveAs en fournissant un nom de fichier.

Fichier Excel de sortie

// 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 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 format

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 
{
    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}");
}

Imports System
Imports System.IO

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 Try

Comment ajouter du style aux fichiers Excel avec IronXL?

Voyons 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 WorkingWithIronXL
{
    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");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    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");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create a new workbook
			Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
			' Create a new worksheet
			Dim workSheet As 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")
		End Sub
	End Class
End Namespace

Explication du code

1. Créez un fichier Excel en utilisant WorkBook.Create.
2. Créez une feuille de calcul en utilisant workBook.CreateWorkSheet.
3. Ajoutez des valeurs aux cellules en utilisant workSheet["A1"].Value.
4. Ajoutez des styles aux cellules en utilisant des propriétés comme workSheet["A1"].Style.Font.Bold.
5. Enregistrez le classeur en utilisant workBook.SaveAs.

Fichier Excel de sortie

Feuille de calcul Excel affichant le texte rouge italique " This Styled Text with Awesome IronXL library " dans la cellule A1, et " 999999 " en vert dans la cellule A2.

// 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
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
Next

// 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
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)

Comment puis-je lire des valeurs depuis Excel et effectuer des calculs ?

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 WorkingWithIronXL
{
    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}");
        }
    }
}

using IronXL;
using System;

namespace WorkingWithIronXL
{
    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}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronXL
Imports System

Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ReadData()
			' Load the Excel worksheet
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			' Select the first worksheet
			Dim workSheet As WorkSheet = workBook.WorkSheets(0)
			' Read a specific cell value
			Dim cellValue As Integer = workSheet("A2").IntValue
			Console.WriteLine($"Value in A2: {cellValue}")
			' Read a range of cells
			For Each cell In workSheet("A1:H10")
				Console.Write($"{cell.Text}" & vbTab)
				If cell.AddressString.Contains("H") Then
					Console.WriteLine()
				End If
			Next cell
			' Calculate aggregate values
			Dim sum As Decimal = workSheet("F2:F10").Sum()
			Console.WriteLine($"Sum of F2:F10: {sum}")
		End Sub
	End Class
End Namespace

Explication du code

1. Chargez un fichier Excel en utilisant WorkBook.Load.
2. Accédez à la première feuille de calcul dans le classeur.
3. Lisez la valeur d'une cellule spécifique et affichez-la en utilisant Console.WriteLine.
4. Parcourez une plage de cellules et affichez chaque valeur. Imprimez de nouvelles lignes après la colonne H.
5. Calculez la somme des valeurs de la plage F2:F10 et affichez-la.

Fichier Excel d'entrée

Feuille de calcul Excel présentant les données des employés avec des colonnes pour l'identifiant, le prénom, le nom, le sexe, le pays, l'âge, la date et un identifiant unique. 9 lignes d'exemples d'enregistrements d'employés y sont affichées.

Sortie

// 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
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").FormattedCellValue

// 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)
{
    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 If

// 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
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()

Comment convertir un fichier Excel en HTML pour une utilisation sur le Web ?

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 WorkingWithIronXL
{
    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);
        }
    }
}

using IronXL;
using IronXL.Options;

namespace WorkingWithIronXL
{
    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);
        }
    }
}

Imports IronXL
Imports IronXL.Options

Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ConvertToHtml()
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			Dim options = New HtmlExportOptions() With {
				.OutputRowNumbers = True,
				.OutputColumnHeaders = True,
				.OutputHiddenRows = True,
				.OutputHiddenColumns = True,
				.OutputLeadingSpacesAsNonBreaking = True
			}
			' Export workbook to the HTML file
			workBook.ExportToHtml("workBook.html", options)
		End Sub
	End Class
End Namespace

Explication du code

1. Chargez le fichier Excel en utilisant la méthode Load.
2. Définissez les options de conversion HTML en utilisant HtmlExportOptions.
3. Utilisez la méthode ExportToHtml pour convertir et enregistrer au format HTML.

Fichier d'entrée

Sortie

Tableau HTML affichant des données Excel avec des colonnes pour Prénom, Nom, Sexe, Pays, Âge, Date et ID, montrant 9 lignes d'exemple de données d'employés.

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

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 As New HtmlExportOptions() With {
    .OutputRowNumbers = True,
    .OutputColumnHeaders = True,
    .OutputHiddenRows = False,
    .OutputHiddenColumns = False,
    .OutputLeadingSpacesAsNonBreaking = True,
    .TableCssClass = "excel-table"
}

// 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
{
    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
})

// 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
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")
Next

Quels sont les cas d'utilisation concrets d' IronXL?

IronXL est une bibliothèque .NET polyvalente avec une large gamme d'applications dans le monde réel, notamment:

1. Rapports d'affaires:

• Automatisation des rapports périodiques tels que les synthèses des ventes et les états financiers.
• Création de tableaux de bord personnalisés à partir de diverses sources de données.
• Exporter les données vers Excel pour les présentations aux parties prenantes.

2. Analyse de données:

• Traitement de grands ensembles de données pour l'analyse statistique et la transformation.
• Exportation des données analysées pour examen par les parties prenantes.
• Utilisation de fonctions d'agrégation pour obtenir rapidement des informations.

3. Gestion des stocks:

• Gestion des stocks de produits avec les niveaux de stock et les informations sur les fournisseurs.
• Générer des rapports d'inventaire pour suivre les tendances.
• Importation des données CSV provenant des fournisseurs.

4. Gestion de la relation client (CRM):

• Exportation des données clients pour une analyse détaillée.
• Mise à jour des enregistrements CRM par importation des données modifiées .
• Création de rapports de segmentation à l'aide d' une mise en forme conditionnelle .

5. Établissements d'enseignement:

• Création des carnets de notes et des registres de présence des élèves.
• Générer les résultats des examens et l'analyse des performances.
• Utilisation de formules pour calculer automatiquement les notes.

6. Services financiers:

• Automatisation des modèles financiers, des budgets et des prévisions.
• Consolidation des données financières pour un rapport complet.
• Création de graphiques pour l'analyse visuelle.

7. Ressources humaines:

• Gestion des données des employés, y compris la paie et les évaluations.
• Générer des rapports sur les indicateurs RH et les données démographiques.
• Protection des données sensibles par chiffrement de mot de passe.

8. Gestion de projet:

• Suivi des échéanciers de projet et de l'affectation des ressources.
• Création de diagrammes de Gantt et d'outils de gestion de projet.
• Utilisation de plages nommées pour la gestion des formules.

9. Commerce électronique :

• Exportation des détails des commandes, des informations client et des données de ventes depuis les plateformes de commerce électronique vers Excel.
• Analyse des tendances de vente, du comportement des clients et de la performance des produits.

10. Santé:

• Gestion des dossiers patients et des plannings de rendez-vous.
• Analyser les données de santé pour améliorer les soins aux patients.
• Sécurisation des données des patients grâce à la protection des feuilles de travail.

Comment obtenir une licence IronXL en vue d'une utilisation en production ?

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

License.LicenseKey = "your Key Here"

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

' 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")

Qu'avons-nous appris sur l'utilisation des fichiers Excel en C# ?

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

• Compatibilité multiplateforme avec Windows, Linux et macOS
• Options complètes de style et de mise en forme
• Prise en charge des formules et des calculs
• Fonctionnalités de sécurité, notamment la protection par mot de passe
• Exportation et importation de données simplifiées
• Excellentes optimisations de performance

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.