IronXL fournit une bibliothèque C# robuste pour la lecture des fichiers CSV qui gère automatiquement les scénarios d'analyse complexes, prend en charge plusieurs délimiteurs et convertit de manière transparente au format Excel sans nécessiter l'installation de Microsoft Office - parfait pour les déploiements conteneurisés et les environnements cloud.
Les fichiers CSV (Comma-Separated Values) sont omniprésents dans les applications d'entreprise, des rapports financiers aux exportations de données clients. Bien qu'elles paraissent simples, l'analyse des fichiers CSV peut rapidement devenir complexe lorsqu'il s'agit de gérer différents séparateurs de colonnes, des champs entre guillemets et diverses conversions de types de données. IronXL est une bibliothèque .NET robuste qui fournit une gestion CSV prête pour l'entreprise, permettant aux développeurs de convertir facilement des données CSV en XML, Excel ou d'autres formats.
Aujourd'hui, nous allons vous expliquer comment IronXL fonctionne en tant que lecteur de fichiers CSV en C# et comment vous pouvez facilement l'implémenter dans vos applications .NET . Essayez IronXL vous-même grâce à l' essai gratuit et suivez les instructions pour découvrir comment il peut améliorer vos tâches .NET CSV et Excel.
StreamReader ?IronXL transforme la lecture des fichiers CSV, véritable casse-tête d'analyse, en opérations simples. Contrairement aux opérations de fractionnement manuelles ou aux approches basiques de StreamReader, IronXL gère automatiquement les cas particuliers tels que les virgules intégrées, les nouvelles lignes, et les colonnes séparées par des délimiteurs inhabituels. L' API robuste de la bibliothèque élimine les erreurs d'analyse syntaxique courantes qui affectent les approches traditionnelles, telles que la gestion incorrecte des champs entre guillemets ou des valeurs de cellules multilignes.
Lors du déploiement sur des environnements conteneurisés, l'architecture autonome d'IronXL signifie que vous n'avez pas besoin de vous soucier d'installer des dépendances supplémentaires ou de gérer les particularités du fichier lié à la plateforme. La bibliothèque gère les limites de taille de fichier avec grâce et fournit un comportement constant, que ce soit sur une station de travail de développeur ou un pod Kubernetes.
Cette bibliothèque fonctionne indépendamment de Microsoft Office, ce qui la rend idéale pour les environnements serveur et les déploiements cloud. Que vous déployiez sur Windows, Linux, macOS, Azure, ou AWS, IronXL offre des résultats cohérents sur toutes les plateformes. Cette compatibilité multiplateforme, associée à son API intuitive, en fait le choix idéal pour les applications C# modernes nécessitant une analyse CSV fiable.
Pour les ingénieurs de DevOps, la compatibilité avec Linux et le support macOS d'IronXL signifient que vous pouvez vous standardiser sur une seule bibliothèque pour l'ensemble de votre pipeline de déploiement. L'empreinte minimale de ressources de la bibliothèque et son utilisation de mémoire efficace garantissent que vos conteneurs restent légers et réactifs, même lors du traitement de gros fichiers CSV.
IronXL traite les fichiers CSV au même titre que les formats Excel, permettant ainsi une transition fluide entre les types de fichiers sans perte de données ni problème de format. Cette capacité de conversion est cruciale pour les pipelines de reporting automatisés où les données CSV se transforment en rapports Excel soignés prêts pour la révision par les parties prenantes.
Au-delà de la simple lecture de fichiers CSV, IronXL prend également en charge l'écriture de fichiers CSV à partir de zéro en utilisant C#. Assurez-vous de consulter notre guide pratique pour en savoir plus. Cela en fait la bibliothèque parfaite pour tous vos besoins CSV, capable de tout faire, de la lecture et la création de fichiers CSV à leur conversion en tout format pris en charge.
L'installation d'IronXL ne prend que quelques instants via le gestionnaire de packages NuGet de Visual Studio. Ouvrez votre projet, cliquez avec le bouton droit sur Références dans l'Explorateur de solutions et sélectionnez " Gérer les packages NuGet ". Recherchez " IronXL" et cliquez sur " Installer ". Pour les déploiements conteneurisés, ajoutez IronXL à votre fichier projet.
<PackageReference Include="IronXL.Excel" Version="2025.*" />
Pour des conseils d'installation détaillés incluant les instructions de configuration Docker, visitez la documentation d'installation d'IronXL. La bibliothèque prend en charge .NET MAUI, Blazor ainsi que les applications .NET traditionnelles tout aussi bien.
Une fois installé, la lecture de votre premier fichier CSV nécessite un minimum de code source, comme le montre l'exemple suivant :
using IronXL;
// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a specific cell
string cellValue = sheet["A1"].StringValue;
// Iterate through rows
foreach (var row in sheet.Rows)
{
foreach (var cell in row)
{
Console.WriteLine(cell.StringValue);
}
}
// Apply aggregate functions
decimal total = sheet["B:B"].Sum();
decimal average = sheet["B:B"].Avg();Imports IronXL
' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue
' Iterate through rows
For Each row In sheet.Rows
For Each cell In row
Console.WriteLine(cell.StringValue)
Next
Next
' Apply aggregate functions
Dim total As Decimal = sheet("B:B").Sum()
Dim average As Decimal = sheet("B:B").Avg()Dans cet exemple, le lecteur accède aux données CSV sous forme de tableaux de chaînes de caractères. La méthode WorkBook.LoadCSV gère l'identification de l'en-tête, crée une table de données et effectue une analyse syntaxique économe en mémoire, simplifiant ainsi la gestion de votre structure de données. La bibliothèque détecte automatiquement l'encodage (prise en charge UTF-8, UTF-16, ASCII) et gère divers formats CSV sans configuration manuelle.
Dans la réalité, les fichiers CSV n'utilisent pas toujours de virgules. Les points-virgules, les barres verticales et les tabulations sont des alternatives courantes, notamment dans les ensembles de données internationaux où les virgules servent de séparateurs décimaux. IronXL gère élégamment tout délimiteur à travers ses options de chargement flexible, assurant que vos applications conteneurisées peuvent traiter les fichiers de diverses sources sans modification.
using IronXL;
// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: ";");
// Load tab-separated values
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "\t");
// Load pipe-delimited files
WorkBook pipeWorkbook = WorkBook.LoadCSV("legacy_export.txt",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "|");
// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();
// Apply math functions for analysis
decimal maxValue = sheet["C:C"].Max();
decimal minValue = sheet["C:C"].Min();Imports IronXL
' Load CSV with semicolon delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv",
fileFormat:=ExcelFileFormat.XLSX,
listDelimiter:=";")
' Load tab-separated values
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv",
fileFormat:=ExcelFileFormat.XLSX,
listDelimiter:=vbTab)
' Load pipe-delimited files
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("legacy_export.txt",
fileFormat:=ExcelFileFormat.XLSX,
listDelimiter:="|")
' Access data normally
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()
' Apply math functions for analysis
Dim maxValue As Decimal = sheet("C:C").Max()
Dim minValue As Decimal = sheet("C:C").Min()Le paramètre listDelimiter accepte n'importe quelle chaîne de caractères, offrant un contrôle total sur le comportement d'analyse. IronXL préserve les valeurs des colonnes et les types de données lors de l'analyse. Les valeurs numériques restent des nombres, les dates demeurent des objets de DateTime, et les formules conservent leurs relations. Cette préservation automatique des types élimine le code de conversion manuelle et réduit les erreurs, ce qui est essentiel pour maintenir l'intégrité des données dans les pipelines automatisés.
Pour les fichiers présentant une mise en forme incohérente, la gestion des erreurs d'IronXL traite avec élégance les lignes malformées sans plantage, en consignant les problèmes pour examen tout en continuant à traiter les données valides. Cette résilience est essentielle pour les environnements de production où les fichiers CSV proviennent de sources externes avec des normes de qualité variables.
Transformer les lignes CSV en objets fortement typés simplifie le traitement des données et permet les opérations LINQ. IronXL simplifie ce mappage grâce à ses méthodes d'accès aux cellules . Le code suivant montre comment créer un analyseur CSV simple avec une gestion des erreurs et une validation appropriées :
using IronXL;
public class Product
{
public string Name { get; set; }
public decimal Price { get; set; }
public int Stock { get; set; }
public DateTime? LastUpdated { get; set; }
}
class Program
{
static void Main(string[] args)
{
// Parse CSV into objects with validation
var products = new List<Product>();
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Skip header row, parse remaining lines
for (int row = 2; row <= sheet.RowCount; row++)
{
try
{
var product = new Product
{
Name = sheet[$"A{row}"].StringValue,
Price = sheet[$"B{row}"].DecimalValue,
Stock = sheet[$"C{row}"].IntValue,
LastUpdated = sheet[$"D{row}"].DateTimeValue
};
// Validate data
if (product.Price > 0 && !string.IsNullOrWhiteSpace(product.Name))
{
products.Add(product);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error parsing row {row}: {ex.Message}");
}
}
// Use LINQ for analysis
var lowStock = products.Where(p => p.Stock < 10).ToList();
var totalInventoryValue = products.Sum(p => p.Price * p.Stock);
// Export results to new Excel file
var reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
var reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report");
// Add headers with formatting
reportSheet["A1"].Value = "Product Name";
reportSheet["B1"].Value = "Current Stock";
reportSheet["C1"].Value = "Unit Price";
reportSheet["A1:C1"].Style.Font.Bold = true;
// Add data
int reportRow = 2;
foreach (var item in lowStock)
{
reportSheet[$"A{reportRow}"].Value = item.Name;
reportSheet[$"B{reportRow}"].Value = item.Stock;
reportSheet[$"C{reportRow}"].Value = item.Price;
reportRow++;
}
reportWorkbook.SaveAs("low_stock_alert.xlsx");
}
}Imports IronXL
Public Class Product
Public Property Name As String
Public Property Price As Decimal
Public Property Stock As Integer
Public Property LastUpdated As DateTime?
End Class
Class Program
Shared Sub Main(ByVal args As String())
' Parse CSV into objects with validation
Dim products = New List(Of Product)()
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Skip header row, parse remaining lines
For row As Integer = 2 To sheet.RowCount
Try
Dim product = New Product With {
.Name = sheet($"A{row}").StringValue,
.Price = sheet($"B{row}").DecimalValue,
.Stock = sheet($"C{row}").IntValue,
.LastUpdated = sheet($"D{row}").DateTimeValue
}
' Validate data
If product.Price > 0 AndAlso Not String.IsNullOrWhiteSpace(product.Name) Then
products.Add(product)
End If
Catch ex As Exception
Console.WriteLine($"Error parsing row {row}: {ex.Message}")
End Try
Next
' Use LINQ for analysis
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim totalInventoryValue = products.Sum(Function(p) p.Price * p.Stock)
' Export results to new Excel file
Dim reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report")
' Add headers with formatting
reportSheet("A1").Value = "Product Name"
reportSheet("B1").Value = "Current Stock"
reportSheet("C1").Value = "Unit Price"
reportSheet("A1:C1").Style.Font.Bold = True
' Add data
Dim reportRow As Integer = 2
For Each item In lowStock
reportSheet($"A{reportRow}").Value = item.Name
reportSheet($"B{reportRow}").Value = item.Stock
reportSheet($"C{reportRow}").Value = item.Price
reportRow += 1
Next
reportWorkbook.SaveAs("low_stock_alert.xlsx")
End Sub
End ClassLes propriétés de valeur typées d'IronXL (StringValue, DecimalValue, IntValue, DateTimeValue) gèrent les conversions en toute sécurité, renvoyant des valeurs par défaut pour les données invalides au lieu de générer des exceptions. Cela évite les tâches manuelles fastidieuses comme la création d'une nouvelle chaîne de caractères pour chaque propriété après l'analyse. Cette approche défensive garantit des applications robustes qui gèrent les données imparfaites avec élégance. Le support des formats de données des cellules de la bibliothèque garantit que les valeurs numériques maintiennent leur précision et que les dates conservent leur formatage.
La bibliothèque prend également en charge les types nullables et la logique d'analyse personnalisée en cas de besoin, permettant ainsi de gérer des règles métier complexes sans sacrifier la simplicité. Pour des scénarios avancés, vous pouvez tirer parti de l'Évaluation des formules Excel d'IronXL pour appliquer des calculs directement dans les données analysées, ou utiliser le formatage conditionnel pour mettre en évidence les anomalies dans les données.
De nombreux processus métier nécessitent des données CSV au format Excel pour des analyses avancées, une mise en forme ou une distribution aux parties prenantes. IronXL simplifie considérablement cette conversion tout en préservant l'intégrité des données. Le processus de conversion est particulièrement précieux lorsque vous devez ajouter des graphiques, appliquer un style aux cellules, ou implémenter une validation des données que les fichiers CSV ne peuvent pas prendre en charge.
// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
// Add advanced formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
// Apply header styling
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";
// Format currency columns
sheet["B:B"].FormatString = "$#,##0.00";
// Add borders to data range
var dataRange = sheet["A1:D100"];
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000");
// Autosize columns for better readability
sheet.AutoSizeColumn(0); // Column A
sheet.AutoSizeColumn(1); // Column B
sheet.AutoSizeColumn(2); // Column C
sheet.AutoSizeColumn(3); // Column D
// Add a summary chart
var chart = sheet.CreateChart(ChartType.Column, 10, 5);
chart.AddSeries("B2:B10", "A2:A10");
chart.SetTitle("Monthly Sales Summary");
chart.Plot();
// Add data validation
sheet["E2:E100"].DataValidation.AllowList = new string[] { "Approved", "Pending", "Rejected" };
// Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx");' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
' Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx")
' Add advanced formatting before saving
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet
' Apply header styling
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"
' Format currency columns
sheet("B:B").FormatString = "$#,##0.00"
' Add borders to data range
Dim dataRange = sheet("A1:D100")
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000")
' Autosize columns for better readability
sheet.AutoSizeColumn(0) ' Column A
sheet.AutoSizeColumn(1) ' Column B
sheet.AutoSizeColumn(2) ' Column C
sheet.AutoSizeColumn(3) ' Column D
' Add a summary chart
Dim chart = sheet.CreateChart(ChartType.Column, 10, 5)
chart.AddSeries("B2:B10", "A2:A10")
chart.SetTitle("Monthly Sales Summary")
chart.Plot()
' Add data validation
sheet("E2:E100").DataValidation.AllowList = New String() {"Approved", "Pending", "Rejected"}
' Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx")La conversion préserve la précision numérique, les formats de date et les caractères spéciaux qui posent souvent problème avec les méthodes de conversion manuelles. IronXL optimise automatiquement la structure du fichier Excel résultant, créant ainsi des fichiers efficaces qui s'ouvrent rapidement même avec de grands ensembles de données. La bibliothèque maintient les commentaires de cellule, les hyperliens, et même les règles de formatage conditionnel pendant la conversion.
Cette capacité de conversion transparente permet des flux de production de rapports automatisés où les données CSV provenant de diverses sources se transforment en rapports Excel soignés, prêts à être examinés par la direction. Vous pouvez créer des tables nommées pour une meilleure organisation des données, appliquer des volets figés pour une navigation facilitée, et même ajouter des images comme des logos d'entreprise pour créer des rapports professionnels.
IronXL intègre plusieurs améliorations avancées qui améliorent la fiabilité du traitement des fichiers CSV. La bibliothèque gère automatiquement différents encodages de texte ( UTF-8, UTF-16, ASCII ), garantissant ainsi un affichage correct des valeurs de chaînes internationales et des colonnes. Le traitement en flux continu économe en mémoire des fichiers CSV volumineux ne nécessite pas le chargement simultané de toutes les données dans la RAM, ce qui est crucial pour les environnements conteneurisés aux ressources limitées.
Pour les déploiements internationaux, IronXL gère correctement différents formats numériques et les représentations de dates. Que votre fichier CSV utilise la notation décimale européenne ou les formats de date américains, la bibliothèque s'adapte automatiquement, réduisant ainsi la configuration spécifique au déploiement.
Lors du traitement de fichiers CSV provenant de sources non fiables, il est recommandé d'encapsuler les opérations dans des blocs try-catch pour plus de sécurité. Pour des stratégies de gestion des erreurs complètes, consultez les guides de dépannage d'IronXL. Mettre en place une journalisation dans les environnements de production afin de suivre les indicateurs de traitement et d'identifier les fichiers problématiques :
using IronXL;
using System.Diagnostics;
public class CSVProcessor
{
private readonly ILogger _logger;
public async Task<ProcessingResult> ProcessCSVBatch(string[] filePaths)
{
var results = new List<FileResult>();
var stopwatch = Stopwatch.StartNew();
foreach (var filePath in filePaths)
{
try
{
var fileStopwatch = Stopwatch.StartNew();
var workbook = WorkBook.LoadCSV(filePath);
var sheet = workbook.DefaultWorkSheet;
// Process data
var recordCount = sheet.RowCount - 1; // Exclude header
var processedRecords = 0;
for (int row = 2; row <= sheet.RowCount; row++)
{
try
{
// Your processing logic here
processedRecords++;
}
catch (Exception rowEx)
{
_logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}");
}
}
results.Add(new FileResult
{
FileName = filePath,
Success = true,
RecordsProcessed = processedRecords,
ProcessingTime = fileStopwatch.ElapsedMilliseconds
});
_logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms");
}
catch (Exception ex)
{
_logger.LogError($"Failed to process {filePath}: {ex.Message}");
results.Add(new FileResult
{
FileName = filePath,
Success = false,
Error = ex.Message
});
}
}
return new ProcessingResult
{
FileResults = results,
TotalProcessingTime = stopwatch.ElapsedMilliseconds,
SuccessRate = (decimal)results.Count(r => r.Success) / results.Count
};
}
}Imports IronXL
Imports System.Diagnostics
Public Class CSVProcessor
Private ReadOnly _logger As ILogger
Public Async Function ProcessCSVBatch(filePaths As String()) As Task(Of ProcessingResult)
Dim results = New List(Of FileResult)()
Dim stopwatch = Stopwatch.StartNew()
For Each filePath In filePaths
Try
Dim fileStopwatch = Stopwatch.StartNew()
Dim workbook = WorkBook.LoadCSV(filePath)
Dim sheet = workbook.DefaultWorkSheet
' Process data
Dim recordCount = sheet.RowCount - 1 ' Exclude header
Dim processedRecords = 0
For row As Integer = 2 To sheet.RowCount
Try
' Your processing logic here
processedRecords += 1
Catch rowEx As Exception
_logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}")
End Try
Next
results.Add(New FileResult With {
.FileName = filePath,
.Success = True,
.RecordsProcessed = processedRecords,
.ProcessingTime = fileStopwatch.ElapsedMilliseconds
})
_logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms")
Catch ex As Exception
_logger.LogError($"Failed to process {filePath}: {ex.Message}")
results.Add(New FileResult With {
.FileName = filePath,
.Success = False,
.Error = ex.Message
})
End Try
Next
Return New ProcessingResult With {
.FileResults = results,
.TotalProcessingTime = stopwatch.ElapsedMilliseconds,
.SuccessRate = CDec(results.Count(Function(r) r.Success)) / results.Count
}
End Function
End ClassPour des performances optimales avec de grands ensembles de données, utilisez les opérations de plage au lieu d'accéder aux cellules individuelles. Le moteur de formules d'IronXL fonctionne également avec les données CSV, permettant des calculs sans conversion préalable en Excel. Considérez ces stratégies d'optimisation :
La prise en charge multiplateforme de la bibliothèque va au-delà de la simple compatibilité. Les conteneurs Docker, les serveurs Linux et les fonctions cloud exécutent tous IronXL sans modification de configuration, ce qui le rend idéal pour les architectures de microservices. Les mesures de sécurité de la bibliothèque assurent une exploitation sûre dans des environnements multi-locataires, tandis que ses options de configuration de licence prennent en charge divers scénarios de déploiement.
Pour les déploiements de conteneurs, les dépendances minimales et l'utilisation efficace des ressources d'IronXL en font un excellent choix. La bibliothèque ne nécessite aucune installation d'Office, de composants COM ni de bibliothèques spécifiques à une plateforme, ce qui simplifie la création de fichiers Dockerfile et réduit la taille des images. Les points de terminaison de contrôle d'intégrité peuvent facilement intégrer les opérations IronXL pour vérifier que les capacités de traitement CSV restent opérationnelles.
IronXL transforme la lecture des fichiers CSV en C#, une tâche fastidieuse, en une solution fiable et adaptée aux entreprises. Son analyseur CSV automatique, sa gestion de la structure des données et ses capacités de conversion Excel transparentes en font le choix idéal pour les développeurs manipulant des fichiers CSV dans les applications .NET modernes. Les améliorations de performances de la bibliothèque dans les versions récentes offrent jusqu'à 40 fois plus de vitesses de traitement tout en réduisant l'utilisation de la mémoire de plus de 95 %.
Que vous construisiez des applications ASP.NET, déployiez sur des fonctions Azure, ou exécutiez dans des clusters Kubernetes, IronXL fournit un traitement CSV cohérent et fiable. La documentation complète de l'API et les nombreux exemples de code assurent un développement et un déploiement rapides.
Prêt à optimiser le traitement de vos fichiers CSV ? Procurez-vous IronXL dès aujourd'hui et bénéficiez d'une gestion des données de niveau entreprise dans vos applications. Avec le support pour VB.NET et toutes les plateformes .NET modernes, IronXL est la solution complète pour vos besoins d'automatisation CSV et Excel.
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.
