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 skomplikowane przypadki dzielenia ciągów znaków.
Bezpłatna próba, aby śledzić i przetestować te przykłady kodu we własnym środowisku.
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ń:
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 wymagana 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.
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 deweloperzy sięgają po ręczne implementacje StreamReader lub pakiety firm trzecich, IronXL oferuje pojedynczą metodę, która obsługuje pliki CSV wraz z formatami Excel bez dodatkowej konfiguracji.
Poniższy kod pokazuje, jak załadować plik CSV, używając metody WorkBook.LoadCSV z 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}");
}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}")
NextMetoda WorkBook.LoadCSV odczytuje plik CSV i tworzy arkusz kalkulacyjny, w którym każda linia staje się wierszem, a każda wartość rozdzielona 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 dostępu do 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.
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 Property Id As Integer
Public Property Name As String = String.Empty
Public Property Price As Decimal
Public Property Quantity As Integer
End ClassPo zdefiniowaniu klasy modelu można analizować rekordy CSV i przekształcać je w kolekcję typu. Poniższy przykład pomija wiersz nagłówkowy, używając indeksu pętli i mapuje każdy kolejny wiersz 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.");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.")Kolekcja records teraz zawiera obiekty Product gotowe do operacji bazodanowych, serializacji do JSON-a 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.
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 warunkowego:
// 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)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.
Budowanie punktu końcowego API, który akceptuje przesyłanie plików CSV z przeglądarki, wymaga połączenia możliwości parsowania IronXL z IFormFile ASP.NET Core. 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}");
}
}
}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 ClassAby akcja [HttpPost("upload")] akceptowała przesyłanie plików, projekt musi obsługiwać multipart form data. W Program.cs dla minimalnej konfiguracji 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 formularza przeglądarki ustaw atrybut enctype formularza na multipart/form-data i użyj elementu do wprowadzania plików. Dla klientów API jak Postman, wybierz "form-data" w treści żądania, dodaj klucz nazwany file, i dołącz plik CSV. Kontroler zwraca obiekt JSON zawierający liczbę rekordów i tablicę sparsowanych danych, które mogą być natychmiast używane przez JavaScript po stronie klienta.
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.");Dim extension As String = Path.GetExtension(file.FileName).ToLowerInvariant()
If extension <> ".csv" AndAlso extension <> ".txt" Then
Return BadRequest("Only CSV files are accepted.")
End IfTa kontrola zapobiega przedostawaniu się nieprawidłowych danych binarnych do parsera i zapewnia jasny komunikat o błędzie dla użytkowników API. Możesz rozszerzyć tę walidację, aby sprawdzić typ MIME przy użyciu file.ContentType dla bardziej rygorystycznego egzekwowania.
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, używając AddRangeAsync Entity Framework Core do masowych wstawień:
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 ClassZarejestruj CsvImportService w Program.cs, aby kontroler mógł ją żądać przez wstrzykiwanie w konstruktorze:
builder.Services.AddScoped<CsvImportService>();netNastępnie zaktualizuj konstruktor kontrolera, aby akceptował usługę i wywoływał ImportProductsAsync zamiast budować listę w treści. To rozdzielenie utrzymuje działania kontrolera cienkie i przenosi logikę dostępu do danych do testowalnej klasy usługowej. Entity Framework Core grupuje wywołanie AddRangeAsync w pojedyncze INSERT na każde zgrupowanie, co działa dobrze dla plików CSV zawierających tysiące wierszy.
Dla bardzo dużych importów (dziesiątki tysięcy wierszy) rozważ użycie Bulk Extensions EF Core lub surowego oświadczenia SQL BULK INSERT, aby zmniejszyć liczbę rund do bazy danych.
IronXL nie ogranicza się do odczytu plików CSV — umożliwia również ich zapis. Metoda SaveAsCsv eksportuje dowolny arkusz kalkulacyjny do pliku CSV, co jest przydatne do generowania raportów lub wysyłania danych do systemów downstream:
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.")Eksportowany plik domyślnie używa separatorów w postaci przecinków. Dla plików rozdzielanych średnikami, powszechnych w lokalizacjach europejskich, wywołaj SaveAsCsv("export.csv", ";") z jawnym argumentem rozdzielającym. Możesz również zapisać do MemoryStream i zwrócić wynik jako pobranie pliku z punktu końcowego API, używając File(stream, "text/csv", "export.csv").
Dla pełnego odniesienia do opcji eksportu, odwiedź dokumentację zapisywania i eksportu IronXL.
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. Poprawne obsługiwanie tego wszystkiego w niestandardowej pętli StreamReader wymaga znacznego testowania i stałego utrzymania.
IronXL rozwiązuje wszystkie te przypadki wewnętrznie. Porównanie tych dwóch podejść pokazuje wyraźne zalety:
| 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 |
Jedną z praktycznych zalet IronXL jest to, że ten sam wzorzec WorkBook.Load i iteracja 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 wykrywa 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.
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:
MemoryStream, aby zmniejszyć alokację pamięci.ws.Rows.Skip(1) z LINQ, aby uniknąć materializacji wiersza nagłówkowego jako obiektu Product.Przewodnik po wydajności IronXL zawiera dodatkowe optymalizacje dla scenariuszy importu dużej liczby, w tym przetwarzanie równoległe i tryby strumieniowe.
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:
Mając IronXL w swoim projekcie, dodanie wsparcia dla przesyłania plików XLSX obok CSV nie wymaga dodatkowych zmian w kodzie -- ten sam wywołanie WorkBook.Load obsługuje oba. Ta spójność oznacza, że możesz stopniowo rozszerzać zestaw funkcji swojego punktu końcowego importu w miarę wzrostu wymagań aplikacji.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
