Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. IronXL verwenden
  4. CSV importieren
IRONXL VERWENDEN

CSV-Import in C# | ASP.NET Core Tutorial | IronXL

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Importieren einer CSV-Datei in C# mit ASP.NET Core bedeutet, einen Dateistream zu lesen, durch Trennzeichen getrennte Zeilen zu parsen und jeden Datensatz einem typisierten Objekt zuzuordnen – all das, bevor man irgendetwas Sinnvolles mit den Daten anfangen kann. IronXL erledigt jeden Schritt über eine einzige API, die gleichermaßen gut für CSV-, XLSX- und TSV-Dateien funktioniert, sodass Sie Ihre Zeit mit der Anwendungslogik verbringen können, anstatt sich mit Sonderfällen der Zeichenkettenaufteilung zu befassen.

Starten Sie Ihre kostenlose Testphase, um die Codebeispiele in Ihrer eigenen Umgebung nachzuvollziehen und zu testen.

Wie installiert man IronXL in einem .NET -Projekt?

Bevor Sie mit dem Schreiben des Parsing-Codes beginnen, fügen Sie IronXL zu Ihrem Projekt hinzu. Öffnen Sie die Paket-Manager-Konsole in Visual Studio oder ein Terminal in Ihrem Projektverzeichnis und führen Sie einen der folgenden Befehle aus:

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

Das Paket ist für .NET 10, .NET 6+, .NET Framework 4.6.2+ und .NET Standard 2.0 geeignet und passt somit zu jedem modernen Projekttyp. Auf dem Server ist keine Installation von Microsoft Office erforderlich. Nachdem das Paket wiederhergestellt wurde, fügen Sie using IronXL; am Anfang jeder Datei hinzu, die die Bibliothek aufruft.

Ausführliche Informationen zu den Einrichtungsoptionen, einschließlich der globalen Tool-Installation und der Konfiguration der CI/CD-Pipeline, finden Sie im IronXL -Installationshandbuch .

Wie importiert man eine CSV-Datei in ASP.NET Core?

Das Importieren einer CSV-Datei in ASP.NET Core erfordert das Lesen des Dateistreams vom Server, das Parsen jeder Zeile und das Zuordnen der Werte zu einer Modellklasse. Während einige Entwickler zu manuellen StreamReader Implementierungen oder Paketen von Drittanbietern greifen, bietet IronXL eine einzige Methode, die CSV-Dateien neben Excel-Formaten ohne zusätzliche Konfiguration verarbeitet.

Der folgende Code zeigt, wie man eine CSV-Datei mit der WorkBook.LoadCSV-Methode von IronXL lädt:

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

Die WorkBook.LoadCSV-Methode verstehen

Die Methode WorkBook.LoadCSV liest die CSV-Datei und erstellt ein Arbeitsblatt, in dem jede Zeile zu einer Zeile und jeder abgegrenzte Wert zu einer Zelle wird. IronXL erkennt automatisch das Trennzeichen (Komma, Semikolon oder Tabulator) und verarbeitet Felder in Anführungszeichen, die Kommas im Wert enthalten. Für Standard-CSV-Dateien ist es nicht notwendig, ein Trennzeichen manuell zu konfigurieren.

Zellwert-Accessoren wie StringValue, DecimalValue, IntValue und DateTimeValue übernehmen die Typkonvertierung, so dass Sie das manuelle Parsen mit int.TryParse oder decimal.Parse vermeiden. Wenn eine Zelle leer ist oder einen unbekannten Wert enthält, geben diese Zugriffsmethoden den Standardwert des Typs zurück, anstatt eine Ausnahme auszulösen. Dadurch werden unbehandelte Fehler bei Massenimportvorgängen vermieden.

Dieser Ansatz eliminiert die fehleranfällige manuelle Zeichenkettenanalyse, die bei benutzerdefinierten Implementierungen erforderlich ist, insbesondere bei Sonderfällen wie maskierten Anführungszeichen, Windows-Zeilenumbrüchen und mehrzeiligen Zellenwerten. Weitere Details zu unterstützten Formaten und Trennzeichenoptionen finden Sie in der IronXL CSV-Dokumentation .

ASP Import CSV: A Complete C# Developer's Guide: Bild 1 - Importieren einer einfachen CSV-Datei und Lesen der Ausgabe in der Konsole

Wie kann man eine Modellklasse für CSV-Daten erstellen?

Die Zuordnung von CSV-Daten zu stark typisierten Objekten erfordert eine Modellklasse, die die Dateistruktur widerspiegelt. Sie wandeln Rohdaten in bestimmte Datentypen wie Ganzzahlen, Dezimalzahlen und DateTime-Werte um. Für Produktinventardaten erstellen Sie eine Klasse mit Eigenschaften, die jeder CSV-Spalte entsprechen:

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

CSV-Zeilen in typisierte Sammlungen parsen

Nachdem die Modellklasse definiert wurde, können Sie CSV-Datensätze in eine typisierte Sammlung parsen. Das folgende Beispiel überspringt die Kopfzeile mit einem Schleifenindex und ordnet jede nachfolgende Zeile einem Product-Objekt zu:

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

Die Sammlung records enthält jetzt typisierte Product Objekte, die für Datenbankoperationen, JSON-Serialisierung oder weitere Geschäftslogik bereit sind. Die Zellenwertzugriffsmethoden von IronXL übernehmen die Typkonvertierung automatisch, einschließlich der Behandlung von Nullwerten für optionale Felder.

Umgang mit optionalen und Nullwerten

In der Praxis enthalten CSV-Dateien oft leere Zellen oder optionale Spalten. Die Wertzugriffsmethoden von IronXL geben Standardwerte anstelle von Ausnahmen zurück, wenn eine Zelle leer ist. Bei Nullable-Typen können Sie eine bedingte Prüfung verwenden:

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

Dieses Muster sorgt für einen defensiven Importcode, ohne jeden Zellenzugriff in einen try-catch-Block einzuschließen. Hinweise zum Umgang mit komplexen Datentypen und großen Dateien finden Sie in der IronXL WorkSheet-Dokumentation .

Wie handhabt man CSV-Datei-Uploads in einer Web-API?

Die Erstellung eines API-Endpunkts, der CSV-Datei-Uploads von einem Browser akzeptiert, erfordert die Kombination von ASP.NET Core IFormFile mit den Parsing-Funktionen von IronXL. Der folgende Code demonstriert eine vollständige Controller-Implementierung, die die hochgeladene Datei analysiert und eine JSON-Antwort zurückgibt:

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

Konfigurieren des Endpunkts und des mehrteiligen Formulars

Damit die Aktion [HttpPost("upload")] Datei-Uploads akzeptiert, muss das Projekt mehrteilige Formulardaten unterstützen. In Program.cs für eine minimale API-Einrichtung, stellen Sie sicher, dass Sie builder.Services.AddControllers() und app.MapControllers() aufgerufen haben. Der Endpunkt wird unter /api/csv/upload zugänglich.

Wenn Sie von einem Browserformular aus testen, setzen Sie das enctype-Attribut des Formulars auf multipart/form-data und verwenden Sie ein Dateieingabeelement. Für API-Clients wie Postman wählen Sie "form-data" im Anforderungskörper, fügen einen Schlüssel namens file hinzu und hängen die CSV-Datei an. Der Controller gibt ein JSON-Objekt zurück, das die Anzahl der Datensätze und das geparste Datenarray enthält, das von clientseitigem JavaScript sofort verwendet werden kann.

ASP Import CSV: A Complete C# Developer's Guide: Bild 2 - Erfolgreiche Ausgabe mit den aus der importierten CSV-Datei gelesenen Daten

Dateityp vor dem Parsen prüfen

Bevor der Datenstrom an IronXL weitergeleitet wird, muss die Dateierweiterung überprüft werden, um Uploads, die nicht im CSV-Format vorliegen, abzulehnen:

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

Diese Prüfung verhindert, dass fehlerhafte Binärdaten den Parser erreichen, und liefert den API-Nutzern eine eindeutige Fehlermeldung. Sie können diese Validierung erweitern, um den MIME-Typ mit file.ContentType für eine strengere Durchsetzung zu prüfen.

Wie speichert man CSV-Daten in einer Datenbank?

Nach dem Parsen von CSV-Dateien in typisierte Objekte werden die Datensätze üblicherweise in einer Datenbank gespeichert. Das folgende Beispiel erweitert das Service-Layer-Muster, indem es AddRangeAsync von Entity Framework Core für Masseneinfügungen verwendet:

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

Einbindung des Dienstes in die Abhängigkeitsinjektion

Registrieren Sie CsvImportService in Program.cs, damit der Controller es durch Konstruktorinjektion anfordern kann:

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

Aktualisieren Sie dann den Controller-Konstruktor, um den Dienst zu akzeptieren und ImportProductsAsync aufzurufen, anstatt die Liste inline zu erstellen. Diese Trennung hält die Controller-Aktionen schlank und verlagert die Datenzugriffslogik in eine testbare Serviceklasse. Entity Framework Core fasst den AddRangeAsync-Aufruf in eine einzige INSERT-Anweisung pro Stapel zusammen, was bei CSV-Dateien mit Tausenden von Zeilen gut funktioniert.

Für sehr große Importe (Zehntausende von Zeilen) sollten Sie EF Core's Bulk Extensions oder eine rohe SQL-Anweisung BULK INSERT verwenden, um die Anzahl der Roundtrips zur Datenbank zu reduzieren.

Wie exportiert man Daten mit IronXL zurück ins CSV-Format?

IronXL beschränkt sich nicht nur auf das Lesen von CSV-Dateien – es kann sie auch schreiben. Die Methode SaveAsCsv exportiert ein beliebiges Arbeitsblatt in eine CSV-Datei, die für die Erstellung von Berichten oder den Versand von Daten an nachgelagerte Systeme nützlich ist:

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

Die exportierte Datei verwendet standardmäßig Komma-Trennzeichen. Für durch Semikolon getrennte Dateien, die in europäischen Ländern üblich sind, rufen Sie SaveAsCsv("export.csv", ";") mit einem expliziten Trennzeichen-Argument auf. Sie können auch in einem MemoryStream speichern und das Ergebnis als Dateidownload von einem API-Endpunkt mit File(stream, "text/csv", "export.csv") zurückgeben.

Eine vollständige Übersicht über die Exportoptionen finden Sie in der IronXL Dokumentation zum Speichern und Exportieren .

Warum ist IronXL eine bessere Wahl als die manuelle CSV-Analyse?

Das manuelle Parsen von CSV-Dateien erscheint unkompliziert, bis man auf Sonderfälle stößt: Werte, die in Anführungszeichen eingeschlossene Kommas, Zeilenumbrüche innerhalb einer Zelle, maskierte Anführungszeichen und Byte-Order-Markierungen am Anfang von UTF-8-Dateien enthalten. Die korrekte Handhabung all dieser Funktionen in einer benutzerdefinierten StreamReader-Schleife erfordert umfangreiche Tests und laufende Wartung.

IronXL kümmert sich intern um all diese Fälle. Der Vergleich der beiden Ansätze zeigt klare Vorteile:

IronXL vs. manueller StreamReader für die CSV-Analyse in C#
Fähigkeit IronXL Manueller StreamReader
Automatische Trennzeichenerkennung Ja Nein – muss manuell konfiguriert werden.
Angebotsfeldbearbeitung Integriert Erfordert benutzerdefinierte Logik
Typkonvertierung (int, decimal, DateTime) Eingebaute Zubehörteile Erfordert Parse/TryParse-Aufrufe
Mehrzeilige Zellenwerte Automatische Verarbeitung Schwer korrekt umzusetzen
Stücklistenverwaltung Automatisch Erfordert StreamReader-Konfiguration
Unterstützung für Excel-Formate (XLSX, XLS) Gleiche API Erfordert eine separate Bibliothek
Exportieren nach CSV SaveAsCsv-Methode Erfordert separate Schreiblogik

Formatübergreifende Konsistenz

Einer der praktischen Vorteile von IronXL ist, dass dasselbe WorkBook.Load und Arbeitsblatt-Iterationsmuster für XLSX-, XLS-, ODS- und CSV-Dateien funktioniert. Wenn Ihre Anwendung mehrere Tabellenkalkulationsformate von Benutzern akzeptieren muss, können Sie zwischen den Formaten wechseln, ohne die Parsing-Logik zu ändern. Übergeben Sie den Dateistrom an WorkBook.Load und IronXL erkennt das Format automatisch anhand der Dateisignatur.

Dank dieser formatübergreifenden API müssen Sie nur einen Codepfad schreiben und testen, anstatt separate Implementierungen für CSV und Excel zu pflegen. Eine vollständige Liste der unterstützten Formate finden Sie auf der IronXL Seite "Unterstützte Dateiformate".

Leistungsüberlegungen für große Dateien

Bei CSV-Dateien unter 100 MB funktioniert IronXL auch ohne Anpassungen einwandfrei. Für größere Dateien sollten Sie folgende Strategien in Betracht ziehen:

  • Laden Sie die Datei aus einem Pfad, anstatt sie in einen MemoryStream zu kopieren, um die Speicherzuweisung zu reduzieren.
  • Die Zeilen werden beim Einfügen in eine Datenbank in Batches verarbeitet, anstatt alle Datensätze vor dem ersten Einfügen zu sammeln.
  • Verwenden Sie ws.Rows.Skip(1) mit LINQ, um zu vermeiden, dass die Kopfzeile als Product Objekt materialisiert wird.

Der IronXL -Leistungsleitfaden enthält zusätzliche Optimierungen für Szenarien mit hohem Importvolumen, einschließlich Parallelverarbeitung und Streaming-Modi.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über ein funktionierendes Muster für jede Phase des CSV-Imports in ASP.NET Core: Installation der Bibliothek, Laden von Dateien von der Festplatte oder aus hochgeladenen Streams, Zuordnung von Zeilen zu typisierten Modellobjekten, Speichern von Datensätzen in einer Datenbank mit Entity Framework Core und Exportieren der Daten zurück in das CSV-Format bei Bedarf.

Um auf dieser Grundlage aufzubauen, erkunden Sie diese Ressourcen:

Mit IronXL in Ihrem Projekt erfordert das Hinzufügen von Unterstützung für XLSX-Uploads neben CSV keine zusätzlichen Code-Änderungen - der gleiche WorkBook.Load-Aufruf behandelt beide. Diese Konsistenz bedeutet, dass Sie den Funktionsumfang Ihres Import-Endpunkts schrittweise erweitern können, wenn Ihre Anwendungsanforderungen wachsen.

Häufig gestellte Fragen

Wie kann ich CSV-Dateien in eine ASP.NET Core -Anwendung importieren?

Mit IronXL können Sie CSV-Dateien in eine ASP.NET Core -Anwendung importieren, indem Sie Datei-Uploads verarbeiten, CSV-Daten parsen und diese Modellklassenobjekten zuordnen. IronXL bietet eine API, die diese Aufgaben effizient unterstützt.

Welche Vorteile bietet die Verwendung von IronXL für den CSV-Import in C#?

IronXL bietet eine API, die den Import von CSV-Dateien vereinfacht. Sie ermöglicht das einfache Parsen von Daten, deren Zuordnung zu Modellen und die Konvertierung von Datensätzen in JSON und ist somit die ideale Wahl für datengetriebene Anwendungen.

Kann IronXL CSV-Daten in Modellklassenobjekte parsen?

Ja, IronXL kann CSV-Daten in Modellklassenobjekte parsen, sodass Sie effizient mit strukturierten Daten innerhalb Ihrer .NET Anwendung arbeiten können.

Wie unterstützt IronXL die Datenbankintegration beim Import von CSV-Dateien?

IronXL unterstützt die Datenbankintegration, indem es Ihnen ermöglicht, CSV-Daten zu parsen und sie Modellobjekten zuzuordnen, die einfach in Ihre Datenbank eingefügt oder aktualisiert werden können.

Ist es möglich, CSV-Datensätze mit IronXL als JSON zurückzugeben?

Ja, mit IronXL können Sie CSV-Datensätze in das JSON-Format konvertieren, was für die Erstellung von Web-APIs oder die Integration mit Frontend-Anwendungen nützlich ist.

Welche Dateiformate kann IronXL außer CSV verarbeiten?

Neben CSV kann IronXL auch verschiedene Excel-Dateiformate wie XLSX, XLS und andere verarbeiten und bietet somit Vielseitigkeit für unterschiedliche Tabellenkalkulationsanforderungen.

Unterstützt IronXL den Import großer CSV-Dateien?

IronXL wurde für den effizienten Import großer CSV-Dateien entwickelt und gewährleistet so Leistung und Zuverlässigkeit in datengetriebenen Anwendungen.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an