Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Importer un fichier CSV
UTILISATION D'IRONXL

Importer un fichier CSV en C# | Tutoriel ASP.NET Core | IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

Importer un fichier CSV en C# avec ASP.NET Core implique de lire un flux de fichier, d'analyser des lignes délimitées et de mapper chaque enregistrement à un objet typé — tout cela avant de pouvoir faire quoi que ce soit d'utile avec les données. IronXL gère chaque étape grâce à une API unique qui fonctionne aussi bien pour les fichiers CSV, XLSX et TSV, vous permettant ainsi de consacrer votre temps à la logique de votre application plutôt qu'à la gestion de cas particuliers liés au fractionnement de chaînes de caractères.

Démarrez votre essai gratuit pour suivre et tester ces exemples de code dans votre propre environnement.

Comment installer IronXL dans un projet .NET ?

Avant d'écrire le moindre code d'analyse syntaxique, ajoutez IronXL à votre projet. Ouvrez la console du gestionnaire de packages dans Visual Studio ou un terminal dans le répertoire de votre projet et exécutez l'une des commandes suivantes :

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

Ce package cible .NET 10, .NET 6+, .NET Framework 4.6.2+ et .NET Standard 2.0, il convient donc à tout type de projet moderne. Aucune installation de Microsoft Office n'est requise sur le serveur. Une fois le paquet restauré, ajoutez using IronXL; au début de tout fichier faisant appel à la bibliothèque.

Pour des options de configuration détaillées, y compris l'installation globale des outils et la configuration du pipeline CI/CD, consultez le guide d'installation IronXL .

Comment importer un fichier CSV dans ASP.NET Core?

L'importation d'un fichier CSV dans ASP.NET Core nécessite la lecture du flux de fichiers depuis le serveur, l'analyse de chaque ligne et le mappage des valeurs à une classe de modèle. Alors que certains développeurs se tournent vers des implémentations StreamReader manuelles ou des packages tiers, IronXL fournit une méthode unique qui gère les fichiers CSV aux côtés des formats Excel sans configuration supplémentaire.

Le code suivant montre comment charger un fichier CSV à l'aide de la méthode WorkBook.LoadCSV d'IronXL :

using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
Imports IronXL

' Load the CSV file directly using the full file path
Dim csv = WorkBook.LoadCSV("products.csv")
Dim worksheet As WorkSheet = csv.DefaultWorkSheet

' Access CSV data by iterating through rows
For Each row In worksheet.Rows
    Dim productName As String = row.Columns(1).StringValue
    Dim price As Decimal = row.Columns(2).DecimalValue
    Console.WriteLine($"Product: {productName}, Price: {price}")
Next
$vbLabelText   $csharpLabel

Comprendre la méthode WorkBook.LoadCSV

La méthode WorkBook.LoadCSV lit le fichier CSV et crée une feuille de calcul où chaque ligne devient une ligne et chaque valeur délimitée une cellule. IronXL détecte automatiquement le délimiteur (virgule, point-virgule ou tabulation) et gère les champs entre guillemets contenant des virgules dans leur valeur. Vous n'avez pas besoin de configurer manuellement un délimiteur pour les fichiers CSV standard.

Les accesseurs de valeur de cellule comme StringValue, DecimalValue, IntValue, et DateTimeValue gèrent la conversion de type afin d'éviter l'analyse manuelle avec int.TryParse ou decimal.Parse. Lorsqu'une cellule est vide ou contient une valeur non reconnue, ces accesseurs renvoient la valeur par défaut du type plutôt que de lever une exception, ce qui évite les erreurs non gérées lors des opérations d'importation en masse.

Cette approche élimine l'analyse manuelle des chaînes de caractères, source d'erreurs, que nécessitent les implémentations personnalisées, notamment pour les cas particuliers comme les guillemets échappés, les fins de ligne de style Windows et les valeurs de cellules multilignes. Pour plus de détails sur les formats pris en charge et les options de délimiteurs, consultez la documentation CSV IronXL .

ASP Import CSV : Guide complet du développeur C# : Image 1 - Importation d'un fichier CSV simple et lecture de la sortie dans la console

Comment créer une classe de modèle pour des données CSV ?

La conversion des données CSV en objets fortement typés nécessite une classe de modèle qui reflète la structure du fichier. Vous convertissez les données brutes de type chaîne en types spécifiques tels que les entiers, les nombres décimaux et les valeurs DateTime. Pour les données d'inventaire des produits, créez une classe avec des propriétés correspondant à chaque colonne CSV :

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
Public Class Product
    Public Property Id As Integer
    Public Property Name As String = String.Empty
    Public Property Price As Decimal
    Public Property Quantity As Integer
End Class
$vbLabelText   $csharpLabel

Analyse des lignes CSV en collections typées

Une fois la classe de modèle définie, vous pouvez analyser les enregistrements CSV et les convertir en une collection typée. L'exemple suivant passe la ligne d'en-tête à l'aide d'un index en boucle et associe chaque ligne suivante à un objet Product :

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of Product)()

' Skip header row (index 0), iterate through data rows
For i As Integer = 1 To ws.Rows.Count() - 1
    Dim row = ws.Rows(i)
    Dim product As New Product With {
        .Id = row.Columns(0).IntValue,
        .Name = row.Columns(1).StringValue,
        .Price = row.Columns(2).DecimalValue,
        .Quantity = row.Columns(3).IntValue
    }
    records.Add(product)
Next

Console.WriteLine($"Loaded {records.Count} products.")
$vbLabelText   $csharpLabel

La collection records contient maintenant des objets Product typés, prêts pour les opérations de base de données, la sérialisation JSON ou une logique commerciale plus poussée. Les accesseurs de valeurs de cellule d'IronXL gèrent automatiquement la conversion de type, y compris la gestion des valeurs nulles pour les champs optionnels.

Gestion des champs optionnels et nullables

Les fichiers CSV réels contiennent souvent des cellules vides ou des colonnes facultatives. Les méthodes d'accès aux valeurs d'IronXL renvoient des valeurs par défaut plutôt que des exceptions lorsqu'une cellule est vide. Pour les types pouvant être nuls, vous pouvez utiliser une vérification conditionnelle :

// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
' Reading an optional DateTime field
Dim lastUpdated As DateTime? = If(String.IsNullOrEmpty(row.Columns(4).StringValue), Nothing, row.Columns(4).DateTimeValue)
$vbLabelText   $csharpLabel

Ce modèle permet de sécuriser votre code d'importation sans avoir à envelopper chaque accès aux cellules dans un bloc try-catch. Pour obtenir des conseils sur la gestion des types de données complexes et des fichiers volumineux, consultez la documentation IronXL WorkSheet .

Comment gérer les chargements de fichiers CSV dans une API Web ?

Construire un point de terminaison API qui accepte les téléchargements de fichiers CSV à partir d'un navigateur nécessite de combiner la IFormFile@ d'ASP.NET Core avec les capacités d'analyse d'IronXL for .NET. Le code suivant illustre une implémentation complète de contrôleur qui analyse le fichier téléchargé et renvoie une réponse JSON :

using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks

<Route("api/[controller]")>
<ApiController>
Public Class CsvController
    Inherits ControllerBase

    <HttpPost("upload")>
    Public Async Function UploadCsv(file As IFormFile) As Task(Of IActionResult)
        If file Is Nothing OrElse file.Length = 0 Then
            Return BadRequest("Please upload a valid CSV file.")
        End If

        Try
            Using stream As New MemoryStream()
                Await file.CopyToAsync(stream)
                stream.Position = 0

                Dim workbook As WorkBook = WorkBook.Load(stream, "csv")
                Dim ws As WorkSheet = workbook.DefaultWorkSheet
                Dim records As New List(Of Product)()

                ' Skip header row, iterate through data rows
                For i As Integer = 1 To ws.Rows.Count() - 1
                    Dim row = ws.Rows(i)
                    records.Add(New Product With {
                        .Id = row.Columns(0).IntValue,
                        .Name = row.Columns(1).StringValue,
                        .Price = row.Columns(2).DecimalValue,
                        .Quantity = row.Columns(3).IntValue
                    })
                Next

                Return Ok(New With {
                    .message = "Import successful",
                    .count = records.Count,
                    .data = records
                })
            End Using
        Catch ex As Exception
            Return BadRequest($"Error processing file: {ex.Message}")
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Configuration du point de terminaison et du formulaire multipartite

Pour que l'action [HttpPost("upload")] accepte les téléchargements de fichiers, le projet doit prendre en charge les données de formulaire multipartites. Dans Program.cs pour une configuration minimale de l'API, assurez-vous d'avoir appelé builder.Services.AddControllers() et app.MapControllers(). Le point final est accessible à l'adresse /api/csv/upload.

Lorsque vous effectuez des tests à partir d'un formulaire de navigateur, définissez l'attribut enctype du formulaire sur multipart/form-data et utilisez un élément d'entrée de fichier. Pour les clients API tels que Postman, sélectionnez "form-data" dans le corps de la demande, ajoutez une clé nommée file, et joignez le fichier CSV. Le contrôleur renvoie un objet JSON contenant le nombre d'enregistrements et le tableau de données analysé, que JavaScript côté client peut consommer immédiatement.

ASP Import CSV : Guide complet du développeur C# : Image 2 - Sortie réussie avec les données lues à partir du fichier CSV importé

Validation du type de fichier avant l'analyse

Avant de transmettre le flux à IronXL, validez l'extension du fichier pour rejeter les téléchargements non CSV :

var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
Dim extension As String = Path.GetExtension(file.FileName).ToLowerInvariant()
If extension <> ".csv" AndAlso extension <> ".txt" Then
    Return BadRequest("Only CSV files are accepted.")
End If
$vbLabelText   $csharpLabel

Ce contrôle empêche les données binaires malformées d'atteindre l'analyseur et fournit un message d'erreur clair aux utilisateurs de l'API. Vous pouvez étendre cette validation pour vérifier le type MIME en utilisant file.ContentType pour une application plus stricte.

Comment enregistrer des données CSV dans une base de données ?

Après avoir analysé les fichiers CSV et les avoir convertis en objets typés, vous enregistrez généralement les données dans une base de données. L'exemple suivant étend le modèle de couche de service en utilisant le AddRangeAsync d'Entity Framework Core pour les insertions en masse :

using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
Imports IronXL

Public Class CsvImportService
    Private ReadOnly _context As AppDbContext

    Public Sub New(context As AppDbContext)
        _context = context
    End Sub

    Public Async Function ImportProductsAsync(csvStream As Stream) As Task(Of Integer)
        Dim workbook As WorkBook = WorkBook.LoadCSV(csvStream)
        Dim ws As WorkSheet = workbook.DefaultWorkSheet
        Dim products As New List(Of Product)()

        For Each row In ws.Rows.Skip(1)
            products.Add(New Product With {
                .Id = row.Columns(0).IntValue,
                .Name = row.Columns(1).StringValue,
                .Price = row.Columns(2).DecimalValue,
                .Quantity = row.Columns(3).IntValue
            })
        Next

        Await _context.Products.AddRangeAsync(products)
        Return Await _context.SaveChangesAsync()
    End Function
End Class
$vbLabelText   $csharpLabel

Intégration du service dans l'injection de dépendances

Enregistrez CsvImportService dans Program.cs pour que le contrôleur puisse le demander par injection de constructeur :

builder.Services.AddScoped<CsvImportService>();
builder.Services.AddScoped<CsvImportService>();
$vbLabelText   $csharpLabel

Mettez ensuite à jour le constructeur du contrôleur pour qu'il accepte le service et appelle ImportProductsAsync au lieu de construire la liste en ligne. Cette séparation permet de limiter les actions du contrôleur et de déplacer la logique d'accès aux données dans une classe de service testable. Entity Framework Core regroupe l'appel AddRangeAsync en une seule déclaration INSERT par lot, ce qui fonctionne bien pour les fichiers CSV contenant des milliers de lignes.

Pour les importations très importantes (des dizaines de milliers de lignes), envisagez d'utiliser EF Core's Bulk Extensions ou une instruction SQL BULK INSERT brute pour réduire les allers-retours vers la base de données.

Comment exporter des données au format CSV avec IronXL?

IronXL ne se limite pas à la lecture des fichiers CSV, il peut également les écrire. La méthode SaveAsCsv exporte n'importe quelle feuille de calcul vers un fichier CSV, ce qui est utile pour générer des rapports ou envoyer des données à des systèmes en aval :

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Write headers
ws("A1").Value = "Id"
ws("B1").Value = "Name"
ws("C1").Value = "Price"

' Write data rows
ws("A2").Value = 1
ws("B2").Value = "Widget A"
ws("C2").Value = 9.99

ws("A3").Value = 2
ws("B3").Value = "Widget B"
ws("C3").Value = 14.49

' Save as CSV
workbook.SaveAsCsv("export.csv")
Console.WriteLine("CSV export complete.")
$vbLabelText   $csharpLabel

Le fichier exporté utilise par défaut des virgules comme délimiteurs. Pour les fichiers délimités par des points-virgules, courants dans les pays européens, appelez SaveAsCsv("export.csv", ";") avec un argument de délimitation explicite. Vous pouvez également enregistrer dans un MemoryStream et renvoyer le résultat sous forme de téléchargement de fichier à partir d'un point de terminaison API en utilisant File(stream, "text/csv", "export.csv").

Pour obtenir une référence complète sur les options d'exportation, consultez la documentation d'enregistrement et d'exportation IronXL .

Pourquoi IronXL est-il un meilleur choix que l'analyse manuelle des fichiers CSV ?

L'analyse manuelle des fichiers CSV semble simple jusqu'à ce que l'on rencontre des cas particuliers : des valeurs contenant des virgules entre guillemets, des sauts de ligne intégrés dans une cellule, des guillemets échappés et des marques d'ordre d'octets au début des fichiers UTF-8. Le traitement correct de tous ces éléments dans une boucle StreamReader personnalisée nécessite des tests importants et une maintenance continue.

IronXL traite tous ces cas en interne. La comparaison des deux approches met en évidence des avantages clairs :

IronXL vs. StreamReader manuel pour l'analyse de fichiers CSV en C#
Capacité IronXL Lecteur de flux manuel
Détection automatique du délimiteur Oui Non – configuration manuelle requise
Traitement sur site indiqué Intégré Nécessite une logique personnalisée
Conversion de type (int, decimal, DateTime) Accessoires intégrés Nécessite des appels Parse/TryParse
Valeurs de cellules multilignes Géré automatiquement Difficile à mettre en œuvre correctement
Gestion de la nomenclature Automatique Nécessite la configuration de StreamReader
Prise en charge des formats Excel (XLSX, XLS) Même API Nécessite une bibliothèque séparée
Exporter vers CSV Méthode SaveAsCsv Nécessite une logique d'écriture séparée

Cohérence inter-formats

L'un des avantages pratiques d'IronXL est que le même WorkBook.Load et le même modèle d'itération des feuilles de travail fonctionnent pour les fichiers XLSX, XLS, ODS et CSV. Si votre application doit accepter plusieurs formats de feuilles de calcul de la part des utilisateurs, vous pouvez passer d'un format à l'autre sans modifier la logique d'analyse. Passez le flux de fichiers à WorkBook.Load et IronXL détecte automatiquement le format en se basant sur la signature du fichier.

Cette API multiformat signifie que vous écrivez et testez un seul chemin de code au lieu de maintenir des implémentations distinctes pour CSV et Excel. Pour obtenir la liste complète des formats pris en charge, consultez la page relative aux formats de fichiers pris en charge par IronXL .

Considérations relatives aux performances des fichiers volumineux

Pour les fichiers CSV de moins de 100 Mo, IronXL fonctionne bien sans aucun réglage. Pour les fichiers volumineux, envisagez les stratégies suivantes :

  • Chargez le fichier à partir d'un chemin d'accès plutôt que de le copier dans un MemoryStream pour réduire l'allocation de mémoire.
  • Traiter les lignes par lots lors de leur insertion dans une base de données plutôt que de collecter tous les enregistrements avant la première insertion.
  • Utilisez ws.Rows.Skip(1) avec LINQ pour éviter de matérialiser la ligne d'en-tête en tant qu'objet Product.

Le guide de performance IronXL couvre des optimisations supplémentaires pour les scénarios d'importation à volume élevé, notamment le traitement parallèle et les modes de diffusion en continu.

Quelles sont vos prochaines étapes ?

Vous disposez désormais d'un modèle fonctionnel pour chaque étape de l'importation CSV dans ASP.NET Core: installation de la bibliothèque, chargement des fichiers depuis le disque ou les flux téléchargés, mappage des lignes sur des objets de modèle typés, persistance des enregistrements dans une base de données avec Entity Framework Core et exportation des données au format CSV en cas de besoin.

Pour approfondir ces bases, explorez ces ressources :

Avec IronXL dans votre projet, l'ajout de la prise en charge des téléchargements XLSX aux côtés des CSV ne nécessite aucune modification supplémentaire du code -- le même appel WorkBook.Load gère les deux. Cette cohérence vous permet d'étendre progressivement les fonctionnalités de votre point de terminaison d'importation à mesure que les besoins de votre application évoluent.

Questions Fréquemment Posées

Comment importer des fichiers CSV dans une application ASP.NET Core ?

Vous pouvez importer des fichiers CSV dans une application ASP.NET Core à l'aide d' IronXL en gérant le chargement des fichiers, l'analyse des données CSV et leur mappage aux objets de la classe modèle. IronXL fournit une API pour faciliter ces tâches.

Quels sont les avantages de l'utilisation IronXL pour l'importation de fichiers CSV en C# ?

IronXL propose une API qui simplifie l'importation de fichiers CSV. Elle permet d'analyser facilement les données, de les associer à des modèles et de convertir les enregistrements en JSON, ce qui en fait un choix idéal pour les applications basées sur les données.

IronXL peut-il analyser des données CSV et les convertir en objets de classe modèle ?

Oui, IronXL peut analyser les données CSV et les convertir en objets de classe modèle, ce qui vous permet de travailler efficacement avec des données structurées au sein de votre application .NET .

Comment IronXL facilite-t-il l'intégration de bases de données lors de l'importation de fichiers CSV ?

IronXL facilite l'intégration des bases de données en vous permettant d'analyser les données CSV et de les mapper à des objets modèles qui peuvent être facilement insérés ou mis à jour dans votre base de données.

Est-il possible de renvoyer des enregistrements CSV au format JSON en utilisant IronXL?

Oui, avec IronXL, vous pouvez convertir des enregistrements CSV au format JSON, ce qui est utile pour créer des API Web ou pour l'intégration avec des applications front-end.

Quels sont les formats de fichiers que IronXL peut gérer en plus du CSV ?

En plus du format CSV, IronXL peut gérer divers formats de fichiers Excel tels que XLSX, XLS et autres, offrant ainsi une grande polyvalence pour répondre à différents besoins en matière de feuilles de calcul.

IronXL prend-il en charge l'importation de fichiers CSV volumineux ?

IronXL est conçu pour gérer efficacement les importations de fichiers CSV volumineux, garantissant ainsi performance et fiabilité dans les applications basées sur les données.

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

Articles connexes

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

Équipe de soutien Iron

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