How to Read Excel Files in C# Without Interop: Complete Developer Guide

Mis à jour:31 janvier 2026

Translated

View the article in English

Maîtrisez la manipulation de fichiers Excel en C# à l'aide de la puissante bibliothèque IronXL, qui lit, valide et exporte les données de feuilles de calcul sans nécessiter l'installation de Microsoft Office. Ce tutoriel complet présente des opérations pratiques dans Excel, notamment la validation des données, la conversion de bases de données et l'intégration d'API REST.

Guide de démarrage rapide : Lire une cellule avec IronXL en une ligne

En une seule ligne, vous pouvez charger un classeur Excel et récupérer la valeur d'une cellule à l'aide d'IronXL. Elle est conçue pour être simple : pas d'Interop, pas de configuration complexe, juste un accès rapide à vos données.

Installez IronXL avec le Gestionnaire de Packages NuGet
PM > Install-Package IronXL.Excel

Copiez et exécutez cet extrait de code.

var value = IronXl.WorkBook.Load("file.xlsx").GetWorkSheet(0)["A1"].StringValue;

Déployez pour tester sur votre environnement de production.

Commencez à utiliser IronXL dans votre projet dès aujourd'hui avec un essai gratuit

Comment configurer IronXL pour lire des fichiers Excel en C# ?

La configuration d'IronXL pour lire des fichiers Excel dans votre projet C# ne prend que quelques minutes. La bibliothèque prend en charge les formats .XLS et .XLSX, ce qui la rend polyvalente pour toute tâche liée à Excel.

Suivez ces étapes pour commencer :

Téléchargez la bibliothèque C# pour lire les fichiers Excel
Charger et lire des classeurs Excel à l'aide de WorkBook.Load()
Accéder aux feuilles de calcul avec la méthode GetWorkSheet()
Lire les valeurs des cellules à l'aide d'une syntaxe intuitive telle que sheet["A1"].Value
Valider et traiter les données de feuilles de calcul par programmation
Exporter des données vers des bases de données à l'aide d'Entity Framework

IronXL excelle dans la lecture et la modification de documents Microsoft Excel avec C#. La bibliothèque fonctionne de manière indépendante : elle ne nécessite ni Microsoft Excel ni Interop pour fonctionner. En effet, IronXL offre une API plus rapide et plus intuitive que Microsoft.Office.Interop.Excel.

IronXL comprend :

Assistance produit dédiée assurée par nos ingénieurs .NET
Installation facile via Microsoft Visual Studio
Essai gratuit pour le développement. Licences de liteLicense

La lecture et la création de fichiers Excel en C# et VB.NET deviennent un jeu d'enfant grâce à la bibliothèque IronXL.

Lecture de fichiers Excel .XLS et .XLSX using IronXL

Voici le processus essentiel pour lire des fichiers Excel à l'aide d'IronXL :

Installez la bibliothèque IronXL Excel via le package NuGet ou téléchargez la DLL .NET Excel
Utilisez la méthode WorkBook.Load() pour lire tout document XLS, XLSX ou CSV
Accéder aux valeurs des cellules à l'aide d'une syntaxe intuitive : sheet["A11"].DecimalValue

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-1.cs

using IronXL;
using System;
using System.Linq;

// Load Excel workbook from file path
WorkBook workBook = WorkBook.Load("test.xlsx");

// Access the first worksheet using LINQ
WorkSheet workSheet = workBook.WorkSheets.First();

// Read integer value from cell A2
int cellValue = workSheet["A2"].IntValue;
Console.WriteLine($"Cell A2 value: {cellValue}");

// Iterate through a range of cells
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Advanced Operations with LINQ
// Calculate sum using built_in Sum() method
decimal sum = workSheet["A2:A10"].Sum();

// Find maximum value using LINQ
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

// Output calculated results
Console.WriteLine($"Sum of A2:A10: {sum}");
Console.WriteLine($"Maximum value: {max}");

Imports IronXL
Imports System
Imports System.Linq

' Load Excel workbook from file path
Dim workBook As WorkBook = WorkBook.Load("test.xlsx")

' Access the first worksheet using LINQ
Dim workSheet As WorkSheet = workBook.WorkSheets.First()

' Read integer value from cell A2
Dim cellValue As Integer = workSheet("A2").IntValue
Console.WriteLine($"Cell A2 value: {cellValue}")

' Iterate through a range of cells
For Each cell In workSheet("A2:A10")
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next

' Advanced Operations with LINQ
' Calculate sum using built_in Sum() method
Dim sum As Decimal = workSheet("A2:A10").Sum()

' Find maximum value using LINQ
Dim max As Decimal = workSheet("A2:A10").Max(Function(c) c.DecimalValue)

' Output calculated results
Console.WriteLine($"Sum of A2:A10: {sum}")
Console.WriteLine($"Maximum value: {max}")

$vbLabelText $csharpLabel

Ce code illustre plusieurs fonctionnalités clés d'IronXL : chargement de classeurs, accès aux cellules par adresse, itération sur des plages et exécution de calculs. La méthode WorkBook.Load() détecte intelligemment les formats de fichiers, tandis que la syntaxe de plage ["A2:A10"] permet une sélection de cellules similaire à celle d'Excel. L'intégration de LINQ permet d'effectuer des requêtes et des agrégations de données puissantes sur des collections de cellules.

Les exemples de code de ce tutoriel s'appuient sur trois feuilles de calcul Excel types qui illustrent différents scénarios de données :

Trois fichiers Excel affichés dans l'Explorateur de solutions de Visual Studio Exemples de fichiers Excel (GDP.xlsx, People.xlsx et PopulationByState.xlsx) utilisés tout au long de ce tutoriel pour illustrer diverses opérations IronXL.

Comment installer la bibliothèque IronXL C# ?

L'installation de la bibliothèque IronXl.Excel ajoute des fonctionnalités Excel complètes à vos projets .NET Framework. Choisissez entre l'installation via NuGet ou l'intégration manuelle de la DLL.

Installation du package NuGet IronXL

Dans Visual Studio, cliquez avec le bouton droit sur votre projet et sélectionnez " Gérer les packages NuGet... "
Recherchez IronXl.Excel dans l'onglet Parcourir
Cliquez sur le bouton Installer pour ajouter IronXL à votre projet

Interface du Package Manager NuGet affichant l'installation du paquet IronXl.Excel L'installation d'IronXL via le Package Manager NuGet de Visual Studio permet une gestion automatique des dépendances.

Vous pouvez également installer IronXL à l'aide de la console du Package Manager :

Ouvrez la console du Package Manager (Outils → Package Manager NuGet → Console du Package Manager)
Exécutez la commande d'installation :

Install-Package IronXL.Excel

Vous pouvez également consulter les détails du package sur le site web de NuGet.

Installation manuelle

Pour une installation manuelle, téléchargez la DLL IronXL.Excel et référencez-la directement dans votre projet Visual Studio.

Comment charger et lire un classeur Excel ?

La classe WorkBook représente un fichier Excel entier. Chargez des fichiers Excel à l'aide de la méthode WorkBook.Load(), qui accepte les chemins d'accès aux fichiers aux formats XLS, XLSX, CSV et TSV.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-2.cs

using IronXL;
using System;
using System.Linq;

// Load Excel file from specified path
WorkBook workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");

Console.WriteLine("Workbook loaded successfully.");

// Access specific worksheet by name
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");

// Read and display cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Perform additional operations
// Count non_empty cells in column A
int rowCount = sheet["A:A"].Count(cell => !cell.IsEmpty);
Console.WriteLine($"Column A has {rowCount} non_empty cells");

Imports IronXL
Imports System
Imports System.Linq

' Load Excel file from specified path
Dim workBook As WorkBook = WorkBook.Load("Spreadsheets\GDP.xlsx")

Console.WriteLine("Workbook loaded successfully.")

' Access specific worksheet by name
Dim sheet As WorkSheet = workBook.GetWorkSheet("Sheet1")

' Read and display cell value
Dim cellValue As String = sheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Perform additional operations
' Count non_empty cells in column A
Dim rowCount As Integer = sheet("A:A").Count(Function(cell) Not cell.IsEmpty)
Console.WriteLine($"Column A has {rowCount} non_empty cells")

$vbLabelText $csharpLabel

Chaque WorkBook contient plusieurs objets WorkSheet représentant des feuilles Excel individuelles. Accédez aux feuilles de calcul par leur nom à l'aide de GetWorkSheet() :

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-3.cs

using IronXL;
using System;

// Get worksheet by name
WorkSheet workSheet = workBook.GetWorkSheet("GDPByCountry");

Console.WriteLine("Worksheet 'GDPByCountry' not found");
// List available worksheets
foreach (var sheet in workBook.WorkSheets)
{
    Console.WriteLine($"Available: {sheet.Name}");
}

Imports IronXL
Imports System

' Get worksheet by name
Dim workSheet As WorkSheet = workBook.GetWorkSheet("GDPByCountry")

Console.WriteLine("Worksheet 'GDPByCountry' not found")
' List available worksheets
For Each sheet In workBook.WorkSheets
    Console.WriteLine($"Available: {sheet.Name}")
Next

$vbLabelText $csharpLabel

Comment créer de nouveaux documents Excel en C# ?

Créez de nouveaux documents Excel en construisant un objet WorkBook avec le format de fichier souhaité. IronXL prend en charge à la fois le format moderne XLSX et l'ancien format XLS.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-4.cs

using IronXL;

// Create new XLSX workbook (recommended format)
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);

// Set workbook metadata
workBook.Metadata.Author = "Your Application";
workBook.Metadata.Comments = "Generated by IronXL";

// Create new XLS workbook for legacy support
WorkBook legacyWorkBook = WorkBook.Create(ExcelFileFormat.XLS);

// Save the workbook
workBook.SaveAs("NewDocument.xlsx");

Imports IronXL

' Create new XLSX workbook (recommended format)
Private workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

' Set workbook metadata
workBook.Metadata.Author = "Your Application"
workBook.Metadata.Comments = "Generated by IronXL"

' Create new XLS workbook for legacy support
Dim legacyWorkBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)

' Save the workbook
workBook.SaveAs("NewDocument.xlsx")

$vbLabelText $csharpLabel

Remarque : n'utilisez ExcelFileFormat.XLS que lorsque la compatibilité avec Excel 2003 et les versions antérieures est requise.

Comment ajouter des feuilles de calcul à un document Excel ?

Un IronXL WorkBook contient un ensemble de feuilles de calcul. Comprendre cette structure est utile lors de la création de fichiers Excel à plusieurs feuilles.

Schéma représentant un classeur contenant plusieurs feuilles de calcul Représentation visuelle de la structure du WorkBook contenant plusieurs objets WorkSheet dans IronXL.

Créer de nouvelles feuilles de calcul à l'aide de CreateWorkSheet() :

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-5.cs

using IronXL;

// Create multiple worksheets with descriptive names
WorkSheet summarySheet = workBook.CreateWorkSheet("Summary");
WorkSheet dataSheet = workBook.CreateWorkSheet("RawData");
WorkSheet chartSheet = workBook.CreateWorkSheet("Charts");

// Set the active worksheet
workBook.SetActiveTab(0); // Makes "Summary" the active sheet

// Access default worksheet (first sheet)
WorkSheet defaultSheet = workBook.DefaultWorkSheet;

Imports IronXL

' Create multiple worksheets with descriptive names
Dim summarySheet As WorkSheet = workBook.CreateWorkSheet("Summary")
Dim dataSheet As WorkSheet = workBook.CreateWorkSheet("RawData")
Dim chartSheet As WorkSheet = workBook.CreateWorkSheet("Charts")

' Set the active worksheet
workBook.SetActiveTab(0) ' Makes "Summary" the active sheet

' Access default worksheet (first sheet)
Dim defaultSheet As WorkSheet = workBook.DefaultWorkSheet

$vbLabelText $csharpLabel

Comment lire et modifier les valeurs des cellules ?

Lire et modifier une cellule unique

Accédez aux cellules individuelles via la propriété Indexer de la feuille de calcul. La classe Cell d'IronXL fournit des propriétés de valeur fortement typées.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-6.cs

using IronXL;
using System;
using System.Linq;

// Load workbook and get worksheet
WorkBook workBook = WorkBook.Load("test.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Access cell B1
IronXL.Cell cell = workSheet["B1"].First();

// Read cell value with type safety
string textValue = cell.StringValue;
int intValue = cell.IntValue;
decimal decimalValue = cell.DecimalValue;
DateTime? dateValue = cell.DateTimeValue;

// Check cell data type
if (cell.IsNumeric)
{
    Console.WriteLine($"Numeric value: {cell.DecimalValue}");
}
else if (cell.IsText)
{
    Console.WriteLine($"Text value: {cell.StringValue}");
}

Imports IronXL
Imports System
Imports System.Linq

' Load workbook and get worksheet
Dim workBook As WorkBook = WorkBook.Load("test.xlsx")
Dim workSheet As WorkSheet = workBook.DefaultWorkSheet

' Access cell B1
Dim cell As IronXL.Cell = workSheet("B1").First()

' Read cell value with type safety
Dim textValue As String = cell.StringValue
Dim intValue As Integer = cell.IntValue
Dim decimalValue As Decimal = cell.DecimalValue
Dim dateValue As DateTime? = cell.DateTimeValue

' Check cell data type
If cell.IsNumeric Then
    Console.WriteLine($"Numeric value: {cell.DecimalValue}")
ElseIf cell.IsText Then
    Console.WriteLine($"Text value: {cell.StringValue}")
End If

$vbLabelText $csharpLabel

La classe Cell offre plusieurs propriétés pour différents types de données, convertissant automatiquement les valeurs lorsque cela est possible. Pour plus d'opérations sur les cellules, consultez le tutoriel sur la mise en forme des cellules.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-7.cs

// Write different data types to cells
workSheet["A1"].Value = "Product Name";     // String
workSheet["B1"].Value = 99.95m;             // Decimal
workSheet["C1"].Value = DateTime.Today;     // Date
workSheet["D1"].Formula = "=B1*1.2";        // Formula
                                            // Format cells
workSheet["B1"].FormatString = "$#,##0.00"; // Currency format
workSheet["C1"].FormatString = "yyyy-MM-dd";// Date format
                                            // Save changes
workBook.Save();

' Write different data types to cells
workSheet("A1").Value = "Product Name" ' String
workSheet("B1").Value = 99.95D ' Decimal
workSheet("C1").Value = DateTime.Today ' Date
workSheet("D1").Formula = "=B1*1.2" ' Formula
											' Format cells
workSheet("B1").FormatString = "$#,##0.00" ' Currency format
workSheet("C1").FormatString = "yyyy-MM-dd" ' Date format
											' Save changes
workBook.Save()

$vbLabelText $csharpLabel

Comment puis-je travailler avec des plages de cellules ?

La classe Range représente une collection de cellules, permettant d'effectuer des opérations en masse sur des données Excel.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-8.cs

using IronXL;
using Range = IronXL.Range;

// Select range using Excel notation
Range range = workSheet["D2:D101"];

// Alternative: Use Range class for dynamic selection
Range dynamicRange = workSheet.GetRange("D2:D101"); // Row 2_101, Column D

// Perform bulk operations
range.Value = 0; // Set all cells to 0

Imports IronXL

' Select range using Excel notation
Dim range As Range = workSheet("D2:D101")

' Alternative: Use Range class for dynamic selection
Dim dynamicRange As Range = workSheet.GetRange("D2:D101") ' Row 2_101, Column D

' Perform bulk operations
range.Value = 0 ' Set all cells to 0

$vbLabelText $csharpLabel

Traiter efficacement les plages à l'aide de boucles lorsque le nombre de cellules est connu :

// Data validation example
public class ValidationResult
{
    public int Row { get; set; }
    public string PhoneError { get; set; }
    public string EmailError { get; set; }
    public string DateError { get; set; }
    public bool IsValid => string.IsNullOrEmpty(PhoneError) && 
                           string.IsNullOrEmpty(EmailError) && 
                           string.IsNullOrEmpty(DateError);
}

// Validate data in rows 2-101
var results = new List<ValidationResult>();

for (int row = 2; row <= 101; row++)
{
    var result = new ValidationResult { Row = row };

    // Get row data efficiently
    var phoneCell = workSheet[$"B{row}"];
    var emailCell = workSheet[$"D{row}"];
    var dateCell = workSheet[$"E{row}"];

    // Validate phone number
    if (!IsValidPhoneNumber(phoneCell.StringValue))
        result.PhoneError = "Invalid phone format";

    // Validate email
    if (!IsValidEmail(emailCell.StringValue))
        result.EmailError = "Invalid email format";

    // Validate date
    if (!dateCell.IsDateTime)
        result.DateError = "Invalid date format";

    results.Add(result);
}

// Helper methods
bool IsValidPhoneNumber(string phone) => 
    System.Text.RegularExpressions.Regex.IsMatch(phone, @"^\d{3}-\d{3}-\d{4}$");

bool IsValidEmail(string email) => 
    email.Co/ntains("@") && email.Co/ntains(".");

// Data validation example
public class ValidationResult
{
    public int Row { get; set; }
    public string PhoneError { get; set; }
    public string EmailError { get; set; }
    public string DateError { get; set; }
    public bool IsValid => string.IsNullOrEmpty(PhoneError) && 
                           string.IsNullOrEmpty(EmailError) && 
                           string.IsNullOrEmpty(DateError);
}

// Validate data in rows 2-101
var results = new List<ValidationResult>();

for (int row = 2; row <= 101; row++)
{
    var result = new ValidationResult { Row = row };

    // Get row data efficiently
    var phoneCell = workSheet[$"B{row}"];
    var emailCell = workSheet[$"D{row}"];
    var dateCell = workSheet[$"E{row}"];

    // Validate phone number
    if (!IsValidPhoneNumber(phoneCell.StringValue))
        result.PhoneError = "Invalid phone format";

    // Validate email
    if (!IsValidEmail(emailCell.StringValue))
        result.EmailError = "Invalid email format";

    // Validate date
    if (!dateCell.IsDateTime)
        result.DateError = "Invalid date format";

    results.Add(result);
}

// Helper methods
bool IsValidPhoneNumber(string phone) => 
    System.Text.RegularExpressions.Regex.IsMatch(phone, @"^\d{3}-\d{3}-\d{4}$");

bool IsValidEmail(string email) => 
    email.Co/ntains("@") && email.Co/ntains(".");

Imports System.Text.RegularExpressions
Imports System.Collections.Generic

' Data validation example
Public Class ValidationResult
    Public Property Row As Integer
    Public Property PhoneError As String
    Public Property EmailError As String
    Public Property DateError As String
    Public ReadOnly Property IsValid As Boolean
        Get
            Return String.IsNullOrEmpty(PhoneError) AndAlso
                   String.IsNullOrEmpty(EmailError) AndAlso
                   String.IsNullOrEmpty(DateError)
        End Get
    End Property
End Class

' Validate data in rows 2-101
Dim results As New List(Of ValidationResult)()

For row As Integer = 2 To 101
    Dim result As New ValidationResult With {.Row = row}

    ' Get row data efficiently
    Dim phoneCell = workSheet($"B{row}")
    Dim emailCell = workSheet($"D{row}")
    Dim dateCell = workSheet($"E{row}")

    ' Validate phone number
    If Not IsValidPhoneNumber(phoneCell.StringValue) Then
        result.PhoneError = "Invalid phone format"
    End If

    ' Validate email
    If Not IsValidEmail(emailCell.StringValue) Then
        result.EmailError = "Invalid email format"
    End If

    ' Validate date
    If Not dateCell.IsDateTime Then
        result.DateError = "Invalid date format"
    End If

    results.Add(result)
Next

' Helper methods
Private Function IsValidPhoneNumber(phone As String) As Boolean
    Return Regex.IsMatch(phone, "^\d{3}-\d{3}-\d{4}$")
End Function

Private Function IsValidEmail(email As String) As Boolean
    Return email.Contains("@") AndAlso email.Contains(".")
End Function

$vbLabelText $csharpLabel

Comment ajouter des formules à des feuilles de calcul Excel ?

Appliquez des formules Excel à l'aide de la propriété Formula. IronXL prend en charge la syntaxe standard des formules Excel.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-9.cs

using IronXL;

// Add formulas to calculate percentages
int lastRow = 50;
for (int row = 2; row < lastRow; row++)
{
    // Calculate percentage: current value / total
    workSheet[$"C{row}"].Formula = $"=B{row}/B{lastRow}";
    // Format as percentage
    workSheet[$"C{row}"].FormatString = "0.00%";
}
// Add summary formulas
workSheet["B52"].Formula = "=SUM(B2:B50)";      // Sum
workSheet["B53"].Formula = "=AVERAGE(B2:B50)";   // Average
workSheet["B54"].Formula = "=MAX(B2:B50)";       // Maximum
workSheet["B55"].Formula = "=MIN(B2:B50)";       // Minimum
                                                 // Force formula evaluation
workBook.EvaluateAll();

Imports IronXL

' Add formulas to calculate percentages
Dim lastRow As Integer = 50
For row As Integer = 2 To lastRow - 1
    ' Calculate percentage: current value / total
    workSheet($"C{row}").Formula = $"=B{row}/B{lastRow}"
    ' Format as percentage
    workSheet($"C{row}").FormatString = "0.00%"
Next
' Add summary formulas
workSheet("B52").Formula = "=SUM(B2:B50)"      ' Sum
workSheet("B53").Formula = "=AVERAGE(B2:B50)"  ' Average
workSheet("B54").Formula = "=MAX(B2:B50)"      ' Maximum
workSheet("B55").Formula = "=MIN(B2:B50)"      ' Minimum
' Force formula evaluation
workBook.EvaluateAll()

$vbLabelText $csharpLabel

Pour modifier des formules existantes, consultez le tutoriel sur les formules Excel.

Comment puis-je valider les données d'une feuille de calcul ?

IronXL permet une validation complète des données pour les feuilles de calcul. Cet exemple valide les numéros de téléphone, les adresses e-mail et les dates à l'aide de bibliothèques externes et des fonctionnalités intégrées de C#.

using System.Text.RegularExpressions;
using IronXL;

// Validation implementation
for (int i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get cells for current person
    var cells = workSheet[$"A{i}:E{i}"].ToList();

    // Validate phone (column B)
    string phone = cells[1].StringValue;
    if (!Regex.IsMatch(phone, @"^\+?1?\d{10,14}$"))
    {
        result.PhoneNumberErrorMessage = "Invalid phone format";
    }

    // Validate email (column D)
    string email = cells[3].StringValue;
    if (!Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
    {
        result.EmailErrorMessage = "Invalid email address";
    }

    // Validate date (column E)
    if (!cells[4].IsDateTime)
    {
        result.DateErrorMessage = "Invalid date format";
    }
}

using System.Text.RegularExpressions;
using IronXL;

// Validation implementation
for (int i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get cells for current person
    var cells = workSheet[$"A{i}:E{i}"].ToList();

    // Validate phone (column B)
    string phone = cells[1].StringValue;
    if (!Regex.IsMatch(phone, @"^\+?1?\d{10,14}$"))
    {
        result.PhoneNumberErrorMessage = "Invalid phone format";
    }

    // Validate email (column D)
    string email = cells[3].StringValue;
    if (!Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
    {
        result.EmailErrorMessage = "Invalid email address";
    }

    // Validate date (column E)
    if (!cells[4].IsDateTime)
    {
        result.DateErrorMessage = "Invalid date format";
    }
}

Imports System.Text.RegularExpressions
Imports IronXL

' Validation implementation
For i As Integer = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	' Get cells for current person
	Dim cells = workSheet($"A{i}:E{i}").ToList()

	' Validate phone (column B)
	Dim phone As String = cells(1).StringValue
	If Not Regex.IsMatch(phone, "^\+?1?\d{10,14}$") Then
		result.PhoneNumberErrorMessage = "Invalid phone format"
	End If

	' Validate email (column D)
	Dim email As String = cells(3).StringValue
	If Not Regex.IsMatch(email, "^[^@\s]+@[^@\s]+\.[^@\s]+$") Then
		result.EmailErrorMessage = "Invalid email address"
	End If

	' Validate date (column E)
	If Not cells(4).IsDateTime Then
		result.DateErrorMessage = "Invalid date format"
	End If
Next i

$vbLabelText $csharpLabel

Économisez les résultats de la validation dans une nouvelle feuille de calcul :

// Create results worksheet
var resultsSheet = workBook.CreateWorkSheet("ValidationResults");

// Add headers
resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

// Style headers
resultsSheet["A1:E1"].Style.Font.Bold = true;
resultsSheet["A1:E1"].Style.SetBackgroundColor("#4472C4");
resultsSheet["A1:E1"].Style.Font.Co/lor = "#FFFFFF";

// Output validation results
for (int i = 0; i < results.Co/unt; i++)
{
    var result = results[i];
    int outputRow = i + 2;

    resultsSheet[$"A{outputRow}"].Value = result.Row;
    resultsSheet[$"B{outputRow}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{outputRow}"].Value = result.PhoneNumberErrorMessage ?? "";
    resultsSheet[$"D{outputRow}"].Value = result.EmailErrorMessage ?? "";
    resultsSheet[$"E{outputRow}"].Value = result.DateErrorMessage ?? "";

    // Highlight invalid rows
    if (!result.IsValid)
    {
        resultsSheet[$"A{outputRow}:E{outputRow}"].Style.SetBackgroundColor("#FFE6E6");
    }
}

// Auto-fit columns
for (int col = 0; col < 5; col++)
{
    resultsSheet.AutoSizeColumn(col);
}

// Save validated workbook
workBook.SaveAs(@"Spreadsheets\PeopleValidated.xlsx");

// Create results worksheet
var resultsSheet = workBook.CreateWorkSheet("ValidationResults");

// Add headers
resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

// Style headers
resultsSheet["A1:E1"].Style.Font.Bold = true;
resultsSheet["A1:E1"].Style.SetBackgroundColor("#4472C4");
resultsSheet["A1:E1"].Style.Font.Co/lor = "#FFFFFF";

// Output validation results
for (int i = 0; i < results.Co/unt; i++)
{
    var result = results[i];
    int outputRow = i + 2;

    resultsSheet[$"A{outputRow}"].Value = result.Row;
    resultsSheet[$"B{outputRow}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{outputRow}"].Value = result.PhoneNumberErrorMessage ?? "";
    resultsSheet[$"D{outputRow}"].Value = result.EmailErrorMessage ?? "";
    resultsSheet[$"E{outputRow}"].Value = result.DateErrorMessage ?? "";

    // Highlight invalid rows
    if (!result.IsValid)
    {
        resultsSheet[$"A{outputRow}:E{outputRow}"].Style.SetBackgroundColor("#FFE6E6");
    }
}

// Auto-fit columns
for (int col = 0; col < 5; col++)
{
    resultsSheet.AutoSizeColumn(col);
}

// Save validated workbook
workBook.SaveAs(@"Spreadsheets\PeopleValidated.xlsx");

Imports System

' Create results worksheet
Dim resultsSheet = workBook.CreateWorkSheet("ValidationResults")

' Add headers
resultsSheet("A1").Value = "Row"
resultsSheet("B1").Value = "Valid"
resultsSheet("C1").Value = "Phone Error"
resultsSheet("D1").Value = "Email Error"
resultsSheet("E1").Value = "Date Error"

' Style headers
resultsSheet("A1:E1").Style.Font.Bold = True
resultsSheet("A1:E1").Style.SetBackgroundColor("#4472C4")
resultsSheet("A1:E1").Style.Font.Color = "#FFFFFF"

' Output validation results
For i As Integer = 0 To results.Count - 1
    Dim result = results(i)
    Dim outputRow As Integer = i + 2

    resultsSheet($"A{outputRow}").Value = result.Row
    resultsSheet($"B{outputRow}").Value = If(result.IsValid, "Yes", "No")
    resultsSheet($"C{outputRow}").Value = If(result.PhoneNumberErrorMessage, "")
    resultsSheet($"D{outputRow}").Value = If(result.EmailErrorMessage, "")
    resultsSheet($"E{outputRow}").Value = If(result.DateErrorMessage, "")

    ' Highlight invalid rows
    If Not result.IsValid Then
        resultsSheet($"A{outputRow}:E{outputRow}").Style.SetBackgroundColor("#FFE6E6")
    End If
Next

' Auto-fit columns
For col As Integer = 0 To 4
    resultsSheet.AutoSizeColumn(col)
Next

' Save validated workbook
workBook.SaveAs("Spreadsheets\PeopleValidated.xlsx")

$vbLabelText $csharpLabel

Comment exporter des données Excel vers une base de données ?

Utilisez IronXL avec Entity Framework pour exporter des données de feuilles de calcul directement vers des bases de données. Cet exemple montre comment exporter les données du PIB d'un pays vers SQLite.

using System;
using System.Com/ponentModel.DataAnnotations;
using Microsoft.EntityFrameworkCore;
using IronXL;

// Define entity model
public class Country
{
    [Key]
    public Guid Id { get; set; } = Guid.NewGuid();

    [Required]
    [MaxLength(100)]
    public string Name { get; set; }

    [Range(0, double.MaxValue)]
    public decimal GDP { get; set; }

    public DateTime ImportedDate { get; set; } = DateTime.UtcNow;
}

using System;
using System.Com/ponentModel.DataAnnotations;
using Microsoft.EntityFrameworkCore;
using IronXL;

// Define entity model
public class Country
{
    [Key]
    public Guid Id { get; set; } = Guid.NewGuid();

    [Required]
    [MaxLength(100)]
    public string Name { get; set; }

    [Range(0, double.MaxValue)]
    public decimal GDP { get; set; }

    public DateTime ImportedDate { get; set; } = DateTime.UtcNow;
}

Imports System
Imports System.ComponentModel.DataAnnotations
Imports Microsoft.EntityFrameworkCore
Imports IronXL

' Define entity model
Public Class Country
    <Key>
    Public Property Id As Guid = Guid.NewGuid()

    <Required>
    <MaxLength(100)>
    Public Property Name As String

    <Range(0, Double.MaxValue)>
    Public Property GDP As Decimal

    Public Property ImportedDate As DateTime = DateTime.UtcNow
End Class

$vbLabelText $csharpLabel

Configurer le contexte Entity Framework pour les opérations sur la base de données :

public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Configure SQLite connection
        optionsBuilder.UseSqlite("Data Source=CountryGDP.db");

        // Enable sensitive data logging in development
        #if DEBUG
        optionsBuilder.EnableSensitiveDataLogging();
        #endif
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configure decimal precision
        modelBuilder.Entity<Country>()
            .Property(c => c.GDP)
            .HasPrecision(18, 2);
    }
}

public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Configure SQLite connection
        optionsBuilder.UseSqlite("Data Source=CountryGDP.db");

        // Enable sensitive data logging in development
        #if DEBUG
        optionsBuilder.EnableSensitiveDataLogging();
        #endif
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configure decimal precision
        modelBuilder.Entity<Country>()
            .Property(c => c.GDP)
            .HasPrecision(18, 2);
    }
}

Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		' Configure SQLite connection
		optionsBuilder.UseSqlite("Data Source=CountryGDP.db")

		' Enable sensitive data logging in development
		#If DEBUG Then
		optionsBuilder.EnableSensitiveDataLogging()
		#End If
	End Sub

	Protected Overrides Sub OnModelCreating(ByVal modelBuilder As ModelBuilder)
		' Configure decimal precision
		modelBuilder.Entity(Of Country)().Property(Function(c) c.GDP).HasPrecision(18, 2)
	End Sub
End Class

$vbLabelText $csharpLabel

Veuillez noterRemarque : pour utiliser différentes bases de données, installez le package NuGet approprié (par exemple, Microsoft.EntityFrameworkCore.SqlServer pour SQL Server) et modifiez la configuration de la connexion en conséquence.

Importer des données Excel dans une base de données :

using System.Threading.Tasks;
using IronXL;
using Microsoft.EntityFrameworkCore;

public async Task ImportGDPDataAsync()
{
    try
    {
        // Load Excel file
        var workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");
        var workSheet = workBook.GetWorkSheet("GDPByCountry");

        using (var context = new CountryContext())
        {
            // Ensure database exists
            await context.Database.EnsureCreatedAsync();

            // Clear existing data (optional)
            await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries");

            // Import data with progress tracking
            int totalRows = 213;
            for (int row = 2; row <= totalRows; row++)
            {
                // Read country data
                var countryName = workSheet[$"A{row}"].StringValue;
                var gdpValue = workSheet[$"B{row}"].DecimalValue;

                // Skip empty rows
                if (string.IsNullOrWhiteSpace(countryName))
                    continue;

                // Create and add entity
                var country = new Country
                {
                    Name = countryName.Trim(),
                    GDP = gdpValue * 1_000_000 // Convert to actual value if in millions
                };

                await context.Co/untries.AddAsync(country);

                // Save in batches for performance
                if (row % 50 == 0)
                {
                    await context.SaveChangesAsync();
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries");
                }
            }

            // Save remaining records
            await context.SaveChangesAsync();
            Console.WriteLine($"Successfully imported {await context.Co/untries.CountAsync()} countries");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Import failed: {ex.Message}");
        throw;
    }
}

using System.Threading.Tasks;
using IronXL;
using Microsoft.EntityFrameworkCore;

public async Task ImportGDPDataAsync()
{
    try
    {
        // Load Excel file
        var workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");
        var workSheet = workBook.GetWorkSheet("GDPByCountry");

        using (var context = new CountryContext())
        {
            // Ensure database exists
            await context.Database.EnsureCreatedAsync();

            // Clear existing data (optional)
            await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries");

            // Import data with progress tracking
            int totalRows = 213;
            for (int row = 2; row <= totalRows; row++)
            {
                // Read country data
                var countryName = workSheet[$"A{row}"].StringValue;
                var gdpValue = workSheet[$"B{row}"].DecimalValue;

                // Skip empty rows
                if (string.IsNullOrWhiteSpace(countryName))
                    continue;

                // Create and add entity
                var country = new Country
                {
                    Name = countryName.Trim(),
                    GDP = gdpValue * 1_000_000 // Convert to actual value if in millions
                };

                await context.Co/untries.AddAsync(country);

                // Save in batches for performance
                if (row % 50 == 0)
                {
                    await context.SaveChangesAsync();
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries");
                }
            }

            // Save remaining records
            await context.SaveChangesAsync();
            Console.WriteLine($"Successfully imported {await context.Co/untries.CountAsync()} countries");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Import failed: {ex.Message}");
        throw;
    }
}

Imports System.Threading.Tasks
Imports IronXL
Imports Microsoft.EntityFrameworkCore

Public Async Function ImportGDPDataAsync() As Task
    Try
        ' Load Excel file
        Dim workBook = WorkBook.Load("Spreadsheets\GDP.xlsx")
        Dim workSheet = workBook.GetWorkSheet("GDPByCountry")

        Using context As New CountryContext()
            ' Ensure database exists
            Await context.Database.EnsureCreatedAsync()

            ' Clear existing data (optional)
            Await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries")

            ' Import data with progress tracking
            Dim totalRows As Integer = 213
            For row As Integer = 2 To totalRows
                ' Read country data
                Dim countryName = workSheet($"A{row}").StringValue
                Dim gdpValue = workSheet($"B{row}").DecimalValue

                ' Skip empty rows
                If String.IsNullOrWhiteSpace(countryName) Then
                    Continue For
                End If

                ' Create and add entity
                Dim country As New Country With {
                    .Name = countryName.Trim(),
                    .GDP = gdpValue * 1_000_000 ' Convert to actual value if in millions
                }

                Await context.Countries.AddAsync(country)

                ' Save in batches for performance
                If row Mod 50 = 0 Then
                    Await context.SaveChangesAsync()
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries")
                End If
            Next

            ' Save remaining records
            Await context.SaveChangesAsync()
            Console.WriteLine($"Successfully imported {Await context.Countries.CountAsync()} countries")
        End Using
    Catch ex As Exception
        Console.WriteLine($"Import failed: {ex.Message}")
        Throw
    End Try
End Function

$vbLabelText $csharpLabel

Comment importer des données API dans des feuilles de calcul Excel ?

Combinez IronXL avec des clients HTTP pour alimenter des feuilles de calcul avec des données API en temps réel. Cet exemple utilise RestClient.Net pour récupérer des données sur les pays.

using System;
using System.Co/llections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
using IronXL;

// Define data model matching API response
public class RestCountry
{
    public string Name { get; set; }
    public long Population { get; set; }
    public string Region { get; set; }
    public string NumericCode { get; set; }
    public List<Language> Languages { get; set; }
}

public class Language
{
    public string Name { get; set; }
    public string NativeName { get; set; }
}

// Fetch and process API data
public async Task ImportCountryDataAsync()
{
    using var httpClient = new HttpClient();

    try
    {
        // Call REST API
        var response = await httpClient.GetStringAsync("https://restcountries.com/v3.1/all");
        var countries = JsonConvert.DeserializeObject<List<RestCountry>>(response);

        // Create new workbook
        var workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        var workSheet = workBook.CreateWorkSheet("Countries");

        // Add headers with styling
        string[] headers = { "Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3" };
        for (int col = 0; col < headers.Length; col++)
        {
            var headerCell = workSheet[0, col];
            headerCell.Value = headers[col];
            headerCell.Style.Font.Bold = true;
            headerCell.Style.SetBackgroundColor("#366092");
            headerCell.Style.Font.Co/lor = "#FFFFFF";
        }

        // Import country data
        await ProcessCountryData(countries, workSheet);

        // Save workbook
        workBook.SaveAs("CountriesFromAPI.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"API import failed: {ex.Message}");
    }
}

using System;
using System.Co/llections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
using IronXL;

// Define data model matching API response
public class RestCountry
{
    public string Name { get; set; }
    public long Population { get; set; }
    public string Region { get; set; }
    public string NumericCode { get; set; }
    public List<Language> Languages { get; set; }
}

public class Language
{
    public string Name { get; set; }
    public string NativeName { get; set; }
}

// Fetch and process API data
public async Task ImportCountryDataAsync()
{
    using var httpClient = new HttpClient();

    try
    {
        // Call REST API
        var response = await httpClient.GetStringAsync("https://restcountries.com/v3.1/all");
        var countries = JsonConvert.DeserializeObject<List<RestCountry>>(response);

        // Create new workbook
        var workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        var workSheet = workBook.CreateWorkSheet("Countries");

        // Add headers with styling
        string[] headers = { "Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3" };
        for (int col = 0; col < headers.Length; col++)
        {
            var headerCell = workSheet[0, col];
            headerCell.Value = headers[col];
            headerCell.Style.Font.Bold = true;
            headerCell.Style.SetBackgroundColor("#366092");
            headerCell.Style.Font.Co/lor = "#FFFFFF";
        }

        // Import country data
        await ProcessCountryData(countries, workSheet);

        // Save workbook
        workBook.SaveAs("CountriesFromAPI.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"API import failed: {ex.Message}");
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Net.Http
Imports System.Threading.Tasks
Imports Newtonsoft.Json
Imports IronXL

' Define data model matching API response
Public Class RestCountry
    Public Property Name As String
    Public Property Population As Long
    Public Property Region As String
    Public Property NumericCode As String
    Public Property Languages As List(Of Language)
End Class

Public Class Language
    Public Property Name As String
    Public Property NativeName As String
End Class

' Fetch and process API data
Public Async Function ImportCountryDataAsync() As Task
    Using httpClient As New HttpClient()

        Try
            ' Call REST API
            Dim response As String = Await httpClient.GetStringAsync("https://restcountries.com/v3.1/all")
            Dim countries As List(Of RestCountry) = JsonConvert.DeserializeObject(Of List(Of RestCountry))(response)

            ' Create new workbook
            Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Countries")

            ' Add headers with styling
            Dim headers As String() = {"Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3"}
            For col As Integer = 0 To headers.Length - 1
                Dim headerCell = workSheet(0, col)
                headerCell.Value = headers(col)
                headerCell.Style.Font.Bold = True
                headerCell.Style.SetBackgroundColor("#366092")
                headerCell.Style.Font.Color = "#FFFFFF"
            Next

            ' Import country data
            Await ProcessCountryData(countries, workSheet)

            ' Save workbook
            workBook.SaveAs("CountriesFromAPI.xlsx")
        Catch ex As Exception
            Console.WriteLine($"API import failed: {ex.Message}")
        End Try
    End Using
End Function

$vbLabelText $csharpLabel

L'API renvoie des données JSON au format suivant :

Structure de réponse JSON affichant des données par pays avec des tableaux de langues imbriqués Exemple de réponse JSON de l'API REST Countries affichant des informations hiérarchiques sur les pays.

Traiter et enregistrer les données de l'API dans Excel :

private async Task ProcessCountryData(List<RestCountry> countries, WorkSheet workSheet)
{
    for (int i = 0; i < countries.Co/unt; i++)
    {
        var country = countries[i];
        int row = i + 1; // Start from row 1 (after headers)

        // Write basic country data
        workSheet[$"A{row}"].Value = country.Name;
        workSheet[$"B{row}"].Value = country.Population;
        workSheet[$"C{row}"].Value = country.Region;
        workSheet[$"D{row}"].Value = country.NumericCode;

        // Format population with thousands separator
        workSheet[$"B{row}"].FormatString = "#,##0";

        // Add up to 3 languages
        for (int langIndex = 0; langIndex < Math.Min(3, country.Languages?.Count ?? 0); langIndex++)
        {
            var language = country.Languages[langIndex];
            string columnLetter = ((char)('E' + langIndex)).ToString();
            workSheet[$"{columnLetter}{row}"].Value = language.Name;
        }

        // Add conditional formatting for regions
        if (country.Region == "Europe")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#E6F3FF");
        }
        else if (country.Region == "Asia")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#FFF2E6");
        }

        // Show progress every 50 countries
        if (i % 50 == 0)
        {
            Console.WriteLine($"Processed {i} of {countries.Co/unt} countries");
        }
    }

    // Auto-size all columns
    for (int col = 0; col < 7; col++)
    {
        workSheet.AutoSizeColumn(col);
    }
}

private async Task ProcessCountryData(List<RestCountry> countries, WorkSheet workSheet)
{
    for (int i = 0; i < countries.Co/unt; i++)
    {
        var country = countries[i];
        int row = i + 1; // Start from row 1 (after headers)

        // Write basic country data
        workSheet[$"A{row}"].Value = country.Name;
        workSheet[$"B{row}"].Value = country.Population;
        workSheet[$"C{row}"].Value = country.Region;
        workSheet[$"D{row}"].Value = country.NumericCode;

        // Format population with thousands separator
        workSheet[$"B{row}"].FormatString = "#,##0";

        // Add up to 3 languages
        for (int langIndex = 0; langIndex < Math.Min(3, country.Languages?.Count ?? 0); langIndex++)
        {
            var language = country.Languages[langIndex];
            string columnLetter = ((char)('E' + langIndex)).ToString();
            workSheet[$"{columnLetter}{row}"].Value = language.Name;
        }

        // Add conditional formatting for regions
        if (country.Region == "Europe")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#E6F3FF");
        }
        else if (country.Region == "Asia")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#FFF2E6");
        }

        // Show progress every 50 countries
        if (i % 50 == 0)
        {
            Console.WriteLine($"Processed {i} of {countries.Co/unt} countries");
        }
    }

    // Auto-size all columns
    for (int col = 0; col < 7; col++)
    {
        workSheet.AutoSizeColumn(col);
    }
}

Imports System
Imports System.Threading.Tasks

Private Async Function ProcessCountryData(countries As List(Of RestCountry), workSheet As WorkSheet) As Task
    For i As Integer = 0 To countries.Count - 1
        Dim country = countries(i)
        Dim row As Integer = i + 1 ' Start from row 1 (after headers)

        ' Write basic country data
        workSheet($"A{row}").Value = country.Name
        workSheet($"B{row}").Value = country.Population
        workSheet($"C{row}").Value = country.Region
        workSheet($"D{row}").Value = country.NumericCode

        ' Format population with thousands separator
        workSheet($"B{row}").FormatString = "#,##0"

        ' Add up to 3 languages
        For langIndex As Integer = 0 To Math.Min(3, If(country.Languages?.Count, 0)) - 1
            Dim language = country.Languages(langIndex)
            Dim columnLetter As String = ChrW(AscW("E"c) + langIndex).ToString()
            workSheet($"{columnLetter}{row}").Value = language.Name
        Next

        ' Add conditional formatting for regions
        If country.Region = "Europe" Then
            workSheet($"C{row}").Style.SetBackgroundColor("#E6F3FF")
        ElseIf country.Region = "Asia" Then
            workSheet($"C{row}").Style.SetBackgroundColor("#FFF2E6")
        End If

        ' Show progress every 50 countries
        If i Mod 50 = 0 Then
            Console.WriteLine($"Processed {i} of {countries.Count} countries")
        End If
    Next

    ' Auto-size all columns
    For col As Integer = 0 To 6
        workSheet.AutoSizeColumn(col)
    Next
End Function

$vbLabelText $csharpLabel

Référence des objets et ressources

Consultez la référence complète de l'API IronXL pour obtenir une documentation détaillée sur les classes et découvrir les fonctionnalités avancées.

Tutoriels supplémentaires sur les opérations Excel :

Résumé

IronXl.Excel est une bibliothèque .NET complète permettant de lire et de manipuler des fichiers Excel dans divers formats. Elle fonctionne de manière autonome sans nécessiter l'installation de Microsoft Excel ou d'Interop.

Pour la manipulation de feuilles de calcul dans le cloud, vous pouvez également explorer la bibliothèque cliente de l'API Google Sheets for .NET, qui complète les capacités de traitement de fichiers locaux d'IronXL for .NET.

Prêt à mettre en œuvre l'automatisation Excel dans vos projets C# ? Téléchargez IronXL ou découvrez les options de licence pour une utilisation en production.

Questions Fréquemment Posées

Comment puis-je lire des fichiers Excel en C# sans utiliser Microsoft Office ?

Vous pouvez utiliser IronXL pour lire des fichiers Excel en C# sans besoin de Microsoft Office. IronXL fournit des méthodes comme WorkBook.Load() pour ouvrir des fichiers Excel et vous permet d'accéder et de manipuler les données avec une syntaxe intuitive.

Quels formats de fichiers Excel peuvent être lus en C# ?

Avec IronXL, vous pouvez lire les formats de fichiers XLS et XLSX en C#. La bibliothèque détecte automatiquement le format de fichier et le traite en conséquence en utilisant la méthode WorkBook.Load().

Comment valider les données Excel en C# ?

IronXL vous permet de valider les données Excel par programme en C# en parcourant les cellules et en appliquant une logique telle que des expressions régulières pour les e-mails ou des fonctions de validation personnalisées. Vous pouvez générer des rapports en utilisant CreateWorkSheet().

Comment puis-je exporter des données d'Excel vers une base de données SQL en C# ?

Pour exporter des données d'Excel vers SQL, utilisez IronXL avec WorkBook.Load() et GetWorkSheet(), puis parcourez les cellules pour transférer les données via Entity Framework.

Puis-je intégrer la fonctionnalité Excel avec des applications ASP.NET Core ?

Oui, IronXL prend en charge l'intégration avec des applications ASP.NET Core. Vous pouvez utiliser les classes WorkBook et WorkSheet dans vos contrôleurs pour gérer les téléchargements de fichiers Excel, générer des rapports, et plus encore.

Est-il possible d'ajouter des formules aux tableurs Excel en C# ?

IronXL vous permet d'ajouter des formules aux tableurs Excel par programme. Vous pouvez définir une formule avec la propriété Formula, comme cell.Formula = "=SUM(A1:A10)" et calculer les résultats avec workBook.EvaluateAll().

Comment puis-je remplir des fichiers Excel avec des données provenant d'une API REST ?

Pour remplir des fichiers Excel avec des données provenant d'une API REST, utilisez IronXL avec un client HTTP pour récupérer les données de l'API, puis écrivez-les dans Excel à l'aide de méthodes comme sheet['A1'].Value. IronXL gère le formatage et la structure Excel.

Quelles sont les options de licence pour utiliser des bibliothèques Excel dans des environnements de production ?

IronXL propose un essai gratuit à des fins de développement, tandis que les licences de production commencent à partir de 749 $. Ces licences incluent un support technique dédié et permettent le déploiement dans divers environnements sans nécessiter de licences Office supplémentaires.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Prêt à commencer?

Nuget Téléchargements 2,041,325 | Version : 2026.6 just released

Voir Licences

Vous faites encore défiler ?

Vous voulez une preuve rapidement ? PM > Install-Package IronXL.Excel
exécuter un échantillon regarder vos données devenir une feuille de calcul.

Voir Licences

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Commencer un essai gratuit de 30 jours

Sur cette page

How to Read Excel Files in C# Without Interop: Complete Developer Guide

Installez IronXL avec le Gestionnaire de Packages NuGet

Copiez et exécutez cet extrait de code.

Déployez pour tester sur votre environnement de production.

Comment configurer IronXL pour lire des fichiers Excel en C# ?

Lecture de fichiers Excel .XLS et .XLSX using IronXL

Comment installer la bibliothèque IronXL C# ?

Installation du package NuGet IronXL

Installation manuelle

Comment charger et lire un classeur Excel ?

Comment créer de nouveaux documents Excel en C# ?

Comment ajouter des feuilles de calcul à un document Excel ?

Comment lire et modifier les valeurs des cellules ?

Lire et modifier une cellule unique

Comment puis-je travailler avec des plages de cellules ?

Comment ajouter des formules à des feuilles de calcul Excel ?

Comment puis-je valider les données d'une feuille de calcul ?

Comment exporter des données Excel vers une base de données ?

Comment importer des données API dans des feuilles de calcul Excel ?

Référence des objets et ressources

Résumé

Questions Fréquemment Posées

Comment puis-je lire des fichiers Excel en C# sans utiliser Microsoft Office ?

Quels formats de fichiers Excel peuvent être lus en C# ?

Comment valider les données Excel en C# ?

Comment puis-je exporter des données d'Excel vers une base de données SQL en C# ?

Puis-je intégrer la fonctionnalité Excel avec des applications ASP.NET Core ?

Est-il possible d'ajouter des formules aux tableurs Excel en C# ?

Comment puis-je remplir des fichiers Excel avec des données provenant d'une API REST ?

Quelles sont les options de licence pour utiliser des bibliothèques Excel dans des environnements de production ?

Vous faites encore défiler ?

Équipe de soutien Iron

Commencer un essai gratuit de 30 jours

Sur cette page

How to Read Excel Files in C# Without Interop: Complete Developer Guide

Installez IronXL avec le Gestionnaire de Packages NuGet

Copiez et exécutez cet extrait de code.

Déployez pour tester sur votre environnement de production.

Comment configurer IronXL pour lire des fichiers Excel en C# ?

Lecture de fichiers Excel .XLS et .XLSX using IronXL

Comment installer la bibliothèque IronXL C# ?

Installation du package NuGet IronXL

Installation manuelle

Comment charger et lire un classeur Excel ?

Comment créer de nouveaux documents Excel en C# ?

Comment ajouter des feuilles de calcul à un document Excel ?

Comment lire et modifier les valeurs des cellules ?

Lire et modifier une cellule unique

Comment puis-je travailler avec des plages de cellules ?

Comment ajouter des formules à des feuilles de calcul Excel ?

Comment puis-je valider les données d'une feuille de calcul ?

Comment exporter des données Excel vers une base de données ?

Comment importer des données API dans des feuilles de calcul Excel ?

Référence des objets et ressources

Résumé

Questions Fréquemment Posées

Comment puis-je lire des fichiers Excel en C# sans utiliser Microsoft Office ?

Quels formats de fichiers Excel peuvent être lus en C# ?

Comment valider les données Excel en C# ?

Comment puis-je exporter des données d'Excel vers une base de données SQL en C# ?

Puis-je intégrer la fonctionnalité Excel avec des applications ASP.NET Core ?

Est-il possible d'ajouter des formules aux tableurs Excel en C# ?

Comment puis-je remplir des fichiers Excel avec des données provenant d'une API REST ?

Quelles sont les options de licence pour utiliser des bibliothèques Excel dans des environnements de production ?

Vous faites encore défiler ?

Obtenez votre GRATUIT

Étape suivante : Commencer l'essai gratuit de 30 jours

Thank You

Étape suivante : Commencer l'essai gratuit de 30 jours

Want to deploy IronSuite to a live project for FREE?

What’s included?

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron