Ikona wiadomości
Przejdź do treści stopki
  1. Iron Software
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Importuj plik CSV
KORZYSTANIE Z IRONXL

Importuj CSV w C# | Samouczek ASP.NET Core | IronXL

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Importowanie pliku CSV w języku C# przy użyciu ASP.NET Core oznacza odczytanie strumienia pliku, analizę wierszy rozdzielonych separatorami oraz mapowanie każdego rekordu do obiektu typu — wszystko to przed podjęciem jakichkolwiek użytecznych działań z danymi. IronXL obsługuje każdy etap za pomocą jednego interfejsu API, który działa równie dobrze w przypadku plików CSV, XLSX i TSV, dzięki czemu możesz poświęcić czas na logikę aplikacji, a nie na skomplikówane przypadki dzielenia ciągów znaków.

Rozpocznij bezpłatny okres próbny, aby śledzić i przetestować te przykłady kodu we własnym środowisku.

Jak zainstalować IronXL w projekcie .NET?

Przed napisaniem jakiegokolwiek kodu parsującego dodaj IronXL do swojego projektu. Otwórz konsolę menedżera pakietów w programie Visual Studio lub terminal w katalogu projektu i uruchom jedno z poniższych poleceń:

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

Pakiet jest przeznaczony dla platform .NET 10, .NET 6+, .NET Framework 4.6.2+ oraz .NET Standard 2.0, dzięki czemu nadaje się do każdego nowoczesnego typu projektu. Na serwerze nie jest wymagańa instalacja pakietu Microsoft Office. Po przywróceniu pakietu dodaj using IronXL; na początku każdego pliku, który wywołuje bibliotekę.

Aby uzyskać szczegółowe informacje na temat opcji konfiguracji, w tym globalnej instalacji narzędzia i konfiguracji potoku CI/CD, zapoznaj się z przewodnikiem instalacji IronXL.

Jak zaimportować plik CSV w ASP.NET Core?

Importowanie pliku CSV w .NET Core wymaga odczytania strumienia pliku z serwera, przeanalizowania każdego wiersza i przyporządkowania wartości do klasy modelu. Podczas gdy niektórzy programiści sięgają po ręczne implementacje StreamReader lub pakiety innych firm, IronXL zapewnia jedną metodę, która obsługuje pliki CSV oraz formaty Excel bez dodatkowej konfiguracji.

Poniższy kod pokazuje, jak załadować plik CSV przy użyciu metody WorkBook.LoadCSV biblioteki 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

Zrozumienie metody WorkBook.LoadCSV

Metoda WorkBook.LoadCSV odczytuje plik CSV i tworzy arkusz, w którym każdy wiersz staje się rzędem, a każda wartość oddzielona separatorem staje się komórką. IronXL automatycznie wykrywa separator (przecinek, średnik lub tabulator) i obsługuje pola w cudzysłowie, które zawierają przecinki w wartości. W przypadku standardowych plików CSV nie ma potrzeby ręcznego konfigurowania separatora.

Akcesory wartości komórek, takie jak StringValue, DecimalValue, IntValue i DateTimeValue obsługują konwersję typów, dzięki czemu można uniknąć ręcznego parsowania za pomocą int.TryParse lub decimal.Parse. Gdy komórka jest pusta lub zawiera nierozpoznaną wartość, te akcesory zwracają wartość domyślną typu zamiast zgłaszać wyjątek, co zapobiega nieobsługiwanym błędom podczas operacji importu zbiorczego.

Takie podejście eliminuje podatne na błędy ręczne parsowanie ciągów znaków, które wymagają niestandardowe implementacje, szczególnie w skrajnych przypadkach, takich jak ucieczki znaków cudzysłowu, końcówki linii w stylu Windows oraz wielowierszowe wartości komórek. Więcej informacji na temat obsługiwanych formatów i opcji separatorów można znaleźć w dokumentacji IronXL CSV.

ASP Import CSV: Kompletny przewodnik dla programistów C#: Obraz 1 — Importowanie prostego pliku CSV i odczytywanie wyników w konsoli

Jak utworzyć klasę modelu dla danych CSV?

Mapowanie danych CSV na obiekty silnie typowane wymaga klasy modelu, która odzwierciedla strukturę pliku. Konwertujesz surowe dane typu string na konkretne typy, takie jak liczby całkowite, ułamki dziesiętne i wartości DateTime. W przypadku danych dotyczących zapasów produktów należy utworzyć klasę z właściwościami odpowiadającymi każdej kolumnie pliku 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

Parsowanie wierszy CSV do kolekcji typowanych

Po zdefiniowaniu klasy modelu można analizować rekordy CSV i przekształcać je w kolekcję typu. W poniższym przykładzie pomijany jest wiersz nagłówkowy przy użyciu indeksu pętli, a każdy kolejny wiersz jest mapowany na obiekt 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

Kolekcja records zawiera teraz obiekty typu Product gotowe do operacji na bazie danych, serializacji JSON lub dalszej logiki biznesowej. Akcesory wartości komórek IronXL automatycznie obsługują konwersję typów, w tym obsługę wartości null dla pól opcjonalnych.

Obsługa pól opcjonalnych i nullable

W rzeczywistych plikach CSV często występują puste komórki lub kolumny opcjonalne. Metody dostępu do wartości w IronXL zwracają wartości domyślne zamiast wyjątków, gdy komórka jest pusta. W przypadku typów nullable można użyć sprawdzania warunkówego:

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

Ten wzorzec pozwala zachować defensywny charakter kodu importującego bez konieczności otaczania każdego dostępu do komórki blokiem try-catch. Wskazówki dotyczące obsługi złożonych typów danych i dużych plików można znaleźć w dokumentacji IronXL WorkSheet.

Jak obsługiwać przesyłanie plików CSV w interfejsie API?

Stworzenie punktu końcowego API, który akceptuje przesyłanie plików CSV z przeglądarki, wymaga połączenia IFormFile z ASP.NET Core z możliwościami parsowania IronXL. Poniższy kod przedstawia kompletną implementację kontrolera, który analizuje przesłany plik i zwraca odpowiedź w formacie 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

Konfiguracja punktu końcowego i formularza wieloczęściowego

Aby akcja [HttpPost("upload")] akceptowała przesyłanie plików, projekt musi obsługiwać dane formularzy wieloczęściowych. W Program.cs, aby uzyskać minimalną konfigurację API, upewnij się, że wywołałeś builder.Services.AddControllers() i app.MapControllers(). Punkt końcowy staje się dostępny pod adresem /api/csv/upload.

Podczas testowania z poziomu formularza przeglądarki należy ustawić atrybut enctype formularza na multipart/form-data i użyć elementu wprowadzania pliku. W przypadku klientów API, takich jak Postman, wybierz "form-data" w treści żądania, dodaj klucz o nazwie file i załącz plik CSV. Kontroler zwraca obiekt JSON zawierający liczbę rekordów i tablicę przeanalizowanych danych, które mogą być natychmiast wykorzystane przez JavaScript po stronie klienta.

ASP Import CSV: Kompletny przewodnik dla programistów C#: Obraz 2 – Pomyślny wynik z danymi odczytanymi z zaimportowanego pliku CSV

Sprawdzanie typu pliku przed parsowaniem

Przed przekazaniem strumienia do IronXL sprawdź rozszerzenie pliku, aby odrzucić pliki inne niż 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

Ta kontrola zapobiega przedostawaniu się nieprawidłowych danych binarnych do parsera i zapewnia jasny komunikat o błędzie dla użytkowników API. Można rozszerzyć tę walidację, aby sprawdzić typ MIME przy użyciu file.ContentType w celu zapewnienia ściślejszego egzekwowania.

Jak zapisać dane CSV w bazie danych?

Po przeanalizowaniu plików CSV i przekształceniu ich w obiekty typu, zazwyczaj zapisuje się rekordy w bazie danych. Poniższy przykład rozszerza wzorzec warstwy usług poprzez wykorzystanie AddRangeAsync z Entity Framework Core do wstawiania zbiorczego:

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

Włączenie usługi do wstrzykiwania zależności

Zarejestruj CsvImportService w Program.cs, aby kontroler mógł go zażądać poprzez wstrzyknięcie konstruktora:

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

Następnie zaktualizuj konstruktor kontrolera, aby akceptował usługę i wywoływał ImportProductsAsync zamiast tworzyć listę w kodzie. Takie rozdzielenie sprawia, że akcje kontrolera pozostają proste, a logika dostępu do danych zostaje przeniesiona do klasy usługi, którą można testować. Entity Framework Core grupuje wywołania AddRangeAsync w pojedyncze instrukcje INSERT na partię, co sprawdza się dobrze w przypadku plików CSV zawierających tysiące wierszy.

W przypadku bardzo dużych importów (dziesiątki tysięcy wierszy) warto rozważyć użycie rozszerzeń Bulk Extensions w EF Core lub surowej instrukcji SQL BULK INSERT, aby zmniejszyć liczbę operacji z bazą danych.

Jak wyeksportować dane z powrotem do pliku CSV za pomocą IronXL?

IronXL nie ogranicza się do odczytu plików CSV — umożliwia również ich zapis. Metoda SaveAsCsv eksportuje dowolny arkusz do pliku CSV, co jest przydatne do generowania raportów lub wysyłania danych do systemów niższego szczebla:

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

Eksportowany plik domyślnie używa separatorów w postaci przecinków. W przypadku plików rozdzielanych średnikami, powszechnych w lokalizacjach europejskich, należy wywołać SaveAsCsv("export.csv", ";") z jawnym argumentem separatora. Można również zapisać do MemoryStream i zwrócić wynik jako plik do pobrania z punktu końcowego API za pomocą File(stream, "text/csv", "export.csv").

Pełne informacje na temat opcji eksportu można znaleźć w dokumentacji dotyczącej zapisywania i eksportowania w IronXL.

Dłączego IronXL jest lepszym wyborem niż ręczne parsowanie plików CSV?

Ręczne parsowanie plików CSV wydaje się proste, dopóki nie napotkasz skrajnych przypadków: wartości zawierających przecinki ujęte w cudzysłowy, znaków nowej linii osadzonych w komórce, znaków cudzysłowu z sekwencją escape oraz znaków kolejności bajtów na początku plików UTF-8. Prawidłowe obsłużenie wszystkich tych elementów w niestandardowej pętli StreamReader wymaga znacznych testów i ciągłej konserwacji.

IronXL rozwiązuje wszystkie te przypadki wewnętrznie. Porównanie tych dwóch podejść pokazuje wyraźne zalety:

IronXL a ręczny StreamReader do parsowania plików CSV w języku C#
Możliwości IronXL Podręcznik StreamReader
Automatyczne wykrywanie separatorów Tak Nie — należy skonfigurować ręcznie
Obsługa pól cytowanych Wbudowane Wymaga niestandardowej logiki
Konwersja typów (int, decimal, DateTime) Wbudowane akcesory Wymaga wywołań Parse/TryParse
Wartości komórek wielowierszowych Obsługiwane automatycznie Trudne do poprawnego wdrożenia
Obsługa listy materiałów (BOM) Automatyczne Wymaga konfiguracji StreamReader
Obsługa formatów Excel (XLSX, XLS) To samo API Wymaga osobnej biblioteki
Eksportuj do pliku CSV Metoda SaveAsCsv Wymaga oddzielnej logiki pisania

Spójność między formatami

Jedną z praktycznych zalet IronXL jest to, że ten sam wzorzec iteracji WorkBook.Load i arkusza działa dla plików XLSX, XLS, ODS i CSV. Jeśli Twoja aplikacja musi akceptować wiele formatów arkuszy kalkulacyjnych od użytkowników, możesz przełączać się między formatami bez zmiany logiki parsowania. Przekaż strumień pliku do WorkBook.Load, a IronXL automatycznie wykryje format na podstawie sygnatury pliku.

To wielopłatformowe API oznacza, że piszesz i testujesz jedną ścieżkę kodu zamiast utrzymywać oddzielne implementacje dla CSV i Excela. Pełną listę obsługiwanych formatów można znaleźć na stronie poświęconej formatom plików obsługiwanych przez IronXL.

Kwestie związane z wydajnością w przypadku dużych plików

W przypadku plików CSV o rozmiarze poniżej 100 MB IronXL działa dobrze bez konieczności dostosowywania. W przypadku większych plików warto rozważyć następujące strategie:

  • Załaduj plik ze ścieżki zamiast kopiować go do MemoryStream, aby zmniejszyć alokację pamięci.
  • Podczas wstawiania danych do bazy danych należy przetwarzać wiersze partiami, zamiast gromadzić wszystkie rekordy przed pierwszym wstawieniem.
  • Użyj ws.Rows.Skip(1) z LINQ, aby uniknąć materializacji wiersza nagłówkowego jako obiektu Product.

Przewodnik wydajności IronXL obejmuje dodatkowe optymalizacje dla scenariuszy importu dużych ilości danych, w tym przetwarzanie równoległe i tryby strumieniowe.

Jakie są Twoje kolejne kroki?

Masz teraz gotowy wzorzec dla każdego etapu importu CSV w ASP.NET Core: instalacji biblioteki, ładowania plików z dysku lub strumieni przesłanych, mapowania wierszy na obiekty modelu typowanego, zapisywania rekordów w bazie danych za pomocą Entity Framework Core oraz eksportowania danych z powrotem do CSV w razie potrzeby.

Aby wykorzystać te podstawy, zapoznaj się z poniższymi zasobami:

Dzięki IronXL w Twoim projekcie dodanie obsługi przesyłania plików XLSX obok CSV nie wymaga żadnych dodatkowych zmian w kodzie — to samo wywołanie WorkBook.Load obsługuje oba formaty. Ta spójność oznacza, że możesz stopniowo rozszerzać zestaw funkcji swojego punktu końcowego importu w miarę wzrostu wymagań aplikacji.

Często Zadawane Pytania

Jak zaimportować pliki CSV do aplikacji .NET Core?

W aplikacji ASP.NET Core można importować pliki CSV za pomocą IronXL poprzez obsługę przesyłania plików, parsowanie danych CSV i mapowanie ich do obiektów klasy modelu. IronXL udostępnia API, które pozwala sprawnie wykonywać te zadania.

Jakie są zalety korzystania z IronXL do importu plików CSV w języku C#?

IronXL oferuje API, które upraszcza proces importowania plików CSV. Pozwala ono w łatwy sposób analizować dane, mapować je do modeli i konwertować rekordy do formatu JSON, co czyni je idealnym wyborem dla aplikacji opartych na danych.

Czy IronXL może analizować dane CSV i przekształcać je w obiekty klasy modelowej?

Tak, IronXL może analizować dane CSV i przekształcać je w obiekty klasy modelowej, co pozwala na wydajną pracę z danymi ustrukturyzowanymi w aplikacji .NET.

W jaki sposób IronXL pomaga w integracji baz danych podczas importowania plików CSV?

IronXL ułatwia integrację z bazami danych, umożliwiając analizowanie danych CSV i mapowanie ich na obiekty modelu, które można łatwo wstawiać lub aktualizować w bazie danych.

Czy za pomocą IronXL można zwrócić rekordy CSV w formacie JSON?

Tak, dzięki IronXL można konwertować rekordy CSV do formatu JSON, co jest przydatne przy tworzeniu interfejsów API lub integracji z aplikacjami front-endowymi.

Jakie formaty plików obsługuje IronXL oprócz CSV?

Oprócz plików CSV, IronXL obsługuje różne formaty plików Excel, takie jak XLSX, XLS i inne, zapewniając wszechstronność w zakresie różnych potrzeb związanych z arkuszami kalkulacyjnymi.

Czy IronXL obsługuje import dużych plików CSV?

IronXL został zaprojektowany do wydajnego obsługi importu dużych plików CSV, zapewniając wydajność i niezawodność w aplikacjach opartych na danych.

Jordi Bardia
Jordi Bardia
  Czat z zespołem inżynierów teraz
Inżynier oprogramowania
Jordi jest najbardziej biegły w Pythonie, C# i C++. Kiedy nie wykorzystuje swoich umiejętności w Iron Software, programuje gry. Dzieląc odpowiedzialność za testowanie produktów, rozwój produktów i badania, Jordi wnosi ogromną wartość do ciągłej poprawy produktów. Różnorodne doświadczenia ...
Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie