Zarządzanie plikami CSV jest podstawowym wymogiem w nowoczesnych aplikacjach C#, od generowania raportów biznesowych po eksportowanie rekordów baz danych. Chociaż .NET zapewnia podstawowe możliwości zapisu plików, efektywna obsługa plików CSV, zwłaszcza w przypadku znaków specjalnych, wielu typów danych i dużych zbiorów danych, wymagałaby bardziej niezawodnego rozwiązania. IronXL upraszcza cały ten proces, zapewniając kompleksowe API, które obsługuje operacje CSV, takie jak zapis do CSV w C#, wraz z pełną kompatybilnością z Excelem.
Ten samouczek pokazuje, jak wykorzystać zaawansowane funkcje IronXL do tworzenia, zapisywania i zarządzania plikami CSV w aplikacjach napisanych w języku C#. Poznasz praktyczne techniki obsługi różnych źródeł danych, od prostych kolekcji po złożone tabele danych (DataTables), zachowując jednocześnie przejrzysty i łatwy w utrzymaniu kod.
Zanim przejdziesz do operacji na plikach CSV, musisz zainstalować IronXL w swoim projekcie. Biblioteka obsługuje .NET Framework 4.6.2+ i .NET Core 2+, dzięki czemu jest kompatybilna zarówno ze starszymi, jak i nowoczesnymi aplikacjami. IronXL zapewnia również doskonałą obsługę wielu platform, działając płynnie w środowiskach Windows, Linux i macOS.
Otwórz Visual Studio, przejdź do konsoli menedżera pakietów i wpisz następujące polecenie:
Lub za pomocą .NET CLI
Po zainstalowaniu dodaj przestrzeń nazw IronXL do swojego pliku C#, aby uzyskać dostęp do wszystkich funkcji zarządzania CSV, takich jak zapis danych:
using IronXL;Imports IronXLTa prosta konfiguracja zapewnia natychmiastowy dostęp do zaawansowanych funkcji edycji arkuszy kalkulacyjnych. W przeciwieństwie do tradycyjnych rozwiązań, które wymagają interoperacji z Excelem lub skomplikowanej logiki analizowania plików CSV, IronXL oferuje intuicyjny interfejs API, który radzi sobie ze złożonymi zadaniami w tle. Biblioteka działa niezależnie, bez konieczności instalacji pakietu Microsoft Office, co czyni ją idealną do wdrożeń serwerowych i aplikacji kontenerowych.
Jeśli podczas instalacji lub inicjalizacji biblioteki wystąpił błąd, upewnij się, że projekt jest skierowany do obsługiwanej wersji .NET oraz że wszystkie zależności zostały poprawnie przywrócone.
Tworzenie lub zapisywanie plików CSV od podstaw za pomocą IronXL przebiega według intuicyjnego schematu. Zaczynasz od utworzenia skoroszytu, dodajesz wszystkie dane do komórek, a następnie zapisujesz go w formacie CSV. Takie podejście zapewnia znacznie większą kontrolę niż podstawowe metody łączenia ciągów znaków.
Zanim przejdziemy do głównej logiki tworzenia plików CSV, oto prosta definicja modelu wykorzystująca strukturę klasy publicznej student. Ten model przedstawia dane strukturalne, które możemy później wyeksportować do pliku CSV.
// Define a Student class to model your data
public class Student
{
public string? Name { get; set; }
public int Age { get; set; }
public string? Grade { get; set; }
}Public Class Student
Public Property Name As String
Public Property Age As Integer
Public Property Grade As String
End ClassMożna wypełnić listę obiektów typu Student, a następnie użyć IronXL do ich wydajnego eksportu do pliku CSV. Ten przykład pokazuje, jak mapować właściwości klasy na komórki arkusza:
using System;
using System.Collections.Generic;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create sample data using the student class
List<Student> students = new List<Student>()
{
new Student { Name = "Alice Johnson", Age = 20, Grade = "A" },
new Student { Name = "Brian Smith", Age = 22, Grade = "B+" },
new Student { Name = "Chloe Brown", Age = 19, Grade = "A-" },
new Student { Name = "David Clark", Age = 21, Grade = "B" }
};
// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Students");
// Add headers
sheet["A1"].Value = "Name";
sheet["B1"].Value = "Age";
sheet["C1"].Value = "Grade";
// Add student data to the worksheet
for (int i = 0; i < students.Count; i++)
{
sheet[$"A{i + 2}"].Value = students[i].Name;
sheet[$"B{i + 2}"].IntValue = students[i].Age;
sheet[$"C{i + 2}"].Value = students[i].Grade;
}
// Save as CSV file
workbook.SaveAsCsv("students.csv");
Console.WriteLine("students.csv file has been created successfully!");
}
}Imports System
Imports System.Collections.Generic
Imports IronXL
Class Program
Shared Sub Main(ByVal args As String())
' Create sample data using the student class
Dim students As New List(Of Student)() From {
New Student With {.Name = "Alice Johnson", .Age = 20, .Grade = "A"},
New Student With {.Name = "Brian Smith", .Age = 22, .Grade = "B+"},
New Student With {.Name = "Chloe Brown", .Age = 19, .Grade = "A-"},
New Student With {.Name = "David Clark", .Age = 21, .Grade = "B"}
}
' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Students")
' Add headers
sheet("A1").Value = "Name"
sheet("B1").Value = "Age"
sheet("C1").Value = "Grade"
' Add student data to the worksheet
For i As Integer = 0 To students.Count - 1
sheet($"A{i + 2}").Value = students(i).Name
sheet($"B{i + 2}").IntValue = students(i).Age
sheet($"C{i + 2}").Value = students(i).Grade
Next
' Save as CSV file
workbook.SaveAsCsv("students.csv")
Console.WriteLine("students.csv file has been created successfully!")
End Sub
End Class
Class Student
Public Property Name As String
Public Property Age As Integer
Public Property Grade As String
End ClassWyjaśnienie:
WorkBook i WorkSheet IronXL są używane do tworzenia strukturalnego arkusza kalkulacyjnego w pamięci.SaveAsCsv().
Ten wzorzec jest skalowalny; Dzięki temu można go łatwo dostosować do większych zbiorów danych lub zintegrować z aplikacją, która pobiera dane uczniów z bazy danych lub API.
Na przykład, jeśli podczas zapisywania do pliku wystąpił błąd (np. plik zablokowany lub nieprawidłowa ścieżka), można go elegancko obsłużyć:
try
{
workbook.SaveAsCsv("students.csv");
}
catch (Exception ex)
{
Console.WriteLine($"Error occurred while saving CSV: {ex.Message}");
}Try
workbook.SaveAsCsv("students.csv")
Catch ex As Exception
Console.WriteLine($"Error occurred while saving CSV: {ex.Message}")
End TryDzięki temu Twoja aplikacja pozostanie niezawodna i dostarczy użytkownikom potrzebnych informacji nawet w przypadku wystąpienia problemów z operacjami wejścia/wyjścia plików.
Poniżej znajduje się przykładowy kod służący do utworzenia podstawowego pliku CSV.
static void Main(string[] args)
{
// Create a new workbook
var writer = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = writer.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Price";
sheet["D1"].Value = "Total";
// Add data rows
sheet["A2"].Value = "Widget A";
sheet["B2"].IntValue = 100;
sheet["C2"].DecimalValue = 29.99m;
sheet["D2"].Formula = "=B2*C2";
sheet["A3"].Value = "Widget B";
sheet["B3"].IntValue = 50;
sheet["C3"].DecimalValue = 49.99m;
sheet["D3"].Formula = "=B3*C3";
// Save as new CSV file
writer.SaveAsCsv("sales_report.csv");
}netTen kod tworzy ustrukturyzowany skoroszyt z nagłówkami i danymi, a następnie eksportuje go do formatu CSV. Metoda WorkBook.Create() inicjalizuje nowy arkusz kalkulacyjny w pamięci. Każda komórka może zawierać różne typy danych, takie jak ciągi znaków, liczby całkowite, ułamki dziesiętne, a nawet formuły. Kiedy wywołasz SaveAsCsv(), IronXL automatycznie obsługuje konwersję, odpowiednio zabezpieczając wszelkie znaki specjalne i zachowując integralność danych.
Piękno tego podejścia polega na jego elastyczności. Przed eksportem można edytować dane w arkuszu kalkulacyjnym, stosując formuły, formatowanie lub reguły walidacji. IronXL automatycznie ocenia formuły podczas procesu eksportu, zapewniając, że plik CSV zawiera obliczone wartości, a nie tekst formuły.
W przypadku niestandardowych wymagań dotyczących separatorów, IronXL pozwala na określenie alternatyw dla standardowego przecinka:
// Save with semicolon delimiter for European locale compatibility
workbook.SaveAsCsv("sales_report.csv", ";");net// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");' Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", vbTab)Ta elastyczność zapewnia zgodność z różnymi ustawieniami regionalnymi i wymaganiami aplikacji. Biblioteka automatycznie obsługuje kwestie związane z kodowaniem, zapewniając prawidłowe wyświetlanie znaków w różnych systemach i ustawieniach regionalnych.
Tabelki danych są powszechnie stosowane w aplikacjach .NET do przechowywania danych tabelarycznych z baz danych lub logiki biznesowej. IronXL zapewnia płynną konwersję DataTable do CSV, zachowując nazwy kolumn i typy danych w trakcie całego procesu.
// Create a sample DataTable (simulating database results) to store data
DataTable customerOrders = new DataTable("CustomerOrders");
customerOrders.Columns.Add("OrderID", typeof(int));
customerOrders.Columns.Add("CustomerName", typeof(string));
customerOrders.Columns.Add("OrderDate", typeof(DateTime));
customerOrders.Columns.Add("Amount", typeof(decimal));
// Add sample data
customerOrders.Rows.Add(1001, "Acme Corp", new DateTime(2024, 1, 15), 1250.50m);
customerOrders.Rows.Add(1002, "TechStart Inc", new DateTime(2024, 1, 16), 3500.00m);
customerOrders.Rows.Add(1003, "Global Systems", new DateTime(2024, 1, 17), 875.25m);
// Convert DataTable to CSV using IronXL
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Orders");
// Add headers from DataTable columns
for (int i = 0; i < customerOrders.Columns.Count; i++)
{
sheet.SetCellValue(0, i, customerOrders.Columns[i].ColumnName);
}
// Add data rows
for (int row = 0; row < customerOrders.Rows.Count; row++)
{
for (int col = 0; col < customerOrders.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, customerOrders.Rows[row][col]);
}
}
// Export to CSV
workbook.SaveAsCsv("customer_orders.csv");Imports System
Imports System.Data
Imports IronXL
' Create a sample DataTable (simulating database results) to store data
Dim customerOrders As New DataTable("CustomerOrders")
customerOrders.Columns.Add("OrderID", GetType(Integer))
customerOrders.Columns.Add("CustomerName", GetType(String))
customerOrders.Columns.Add("OrderDate", GetType(DateTime))
customerOrders.Columns.Add("Amount", GetType(Decimal))
' Add sample data
customerOrders.Rows.Add(1001, "Acme Corp", New DateTime(2024, 1, 15), 1250.5D)
customerOrders.Rows.Add(1002, "TechStart Inc", New DateTime(2024, 1, 16), 3500.0D)
customerOrders.Rows.Add(1003, "Global Systems", New DateTime(2024, 1, 17), 875.25D)
' Convert DataTable to CSV using IronXL
Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Orders")
' Add headers from DataTable columns
For i As Integer = 0 To customerOrders.Columns.Count - 1
sheet.SetCellValue(0, i, customerOrders.Columns(i).ColumnName)
Next
' Add data rows
For row As Integer = 0 To customerOrders.Rows.Count - 1
For col As Integer = 0 To customerOrders.Columns.Count - 1
sheet.SetCellValue(row + 1, col, customerOrders.Rows(row)(col))
Next
Next
' Export to CSV
workbook.SaveAsCsv("customer_orders.csv")Ten przykład ilustruje rzeczywistą sytuację, w której dane dotyczące zamówień z bazy danych muszą zostać wyeksportowane do celów raportowania lub integracji. Kod iteruje strukturę DataTable, zachowując nagłówki kolumn i dane wierszy. IronXL odpowiednio obsługuje konwersję różnych typów danych, zapewniając prawidłowe formatowanie dat, liczb dziesiętnych i ciągów znaków w wynikowym pliku CSV.
W przypadku bardziej złożonych scenariuszy obejmujących wiele powiązanych tabel lub zaawansowane transformacje danych można wykorzystać funkcje odwoływania się do komórek i formuły programu IronXL:
// Add summary row with formulas
int lastRow = customerOrders.Rows.Count + 1;
sheet[$"A{lastRow + 1}"].Value = "Total:";
sheet[$"D{lastRow + 1}"].Formula = $"=SUM(D2:D{lastRow})";
// Calculate and save
workbook.SaveAsCsv("customer_orders_with_total.csv");' Add summary row with formulas
Dim lastRow As Integer = customerOrders.Rows.Count + 1
sheet($"A{lastRow + 1}").Value = "Total:"
sheet($"D{lastRow + 1}").Formula = $"=SUM(D2:D{lastRow})"
' Calculate and save
workbook.SaveAsCsv("customer_orders_with_total.csv")Takie podejście zapewnia znacznie większą kontrolę niż tradycyjne metody eksportu z tabeli danych (DataTable). Przed ostatecznym eksportem można dodać pola obliczeniowe, zastosować logikę formatowania warunkowego lub zmienić układ kolumn. Dokumentacja IronXL zawiera obszerne przykłady zaawansowanych scenariuszy manipulacji tabelami danych (DataTable).
Jedną z najsilniejszych cech IronXL jest możliwość płynnej współpracy z istniejącymi plikami Excel, konwertując je do formatu CSV przy zachowaniu integralności danych. Jest to szczególnie przydatne podczas integracji z systemami, które generują raporty w formacie Excel, ale wymagają plików CSV do dalszego przetwarzania.
// Load an existing Excel file
WorkBook existingWorkbook = WorkBook.Load("Budget.xlsx");
// Access the first worksheet
WorkSheet sheet = existingWorkbook.WorkSheets[0];
// Save as CSV - single sheet
sheet.SaveAsCsv("Budget.csv");
// Or save entire workbook (creates multiple CSV files for multiple sheets)
existingWorkbook.SaveAsCsv("BudgetReport.csv");' Load an existing Excel file
Dim existingWorkbook As WorkBook = WorkBook.Load("Budget.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = existingWorkbook.WorkSheets(0)
' Save as CSV - single sheet
sheet.SaveAsCsv("Budget.csv")
' Or save entire workbook (creates multiple CSV files for multiple sheets)
existingWorkbook.SaveAsCsv("BudgetReport.csv")Podczas ładowania plików Excel IronXL zachowuje wszystkie wartości komórek, w tym te obliczone za pomocą formuł. Biblioteka ocenia formuły programu Excel podczas procesu konwersji, zapewniając, że plik CSV zawiera rzeczywiste obliczone wartości. Eliminuje to powszechny problem pojawiania się tekstu formuł w eksportach CSV.
W przypadku skoroszytów zawierających wiele arkuszy IronXL inteligentnie obsługuje każdy arkusz:
// Process multiple sheets
WorkBook multiSheetWorkbook = WorkBook.Load("annual_data.xlsx");
foreach (WorkSheet sheet in multiSheetWorkbook.WorkSheets)
{
string fileName = $"export_{sheet.Name}.csv";
sheet.SaveAsCsv(fileName);
Console.WriteLine($"Exported {sheet.Name} to {fileName}");
}Imports System
' Process multiple sheets
Dim multiSheetWorkbook As WorkBook = WorkBook.Load("annual_data.xlsx")
For Each sheet As WorkSheet In multiSheetWorkbook.WorkSheets
Dim fileName As String = $"export_{sheet.Name}.csv"
sheet.SaveAsCsv(fileName)
Console.WriteLine($"Exported {sheet.Name} to {fileName}")
NextTen kod iteruje przez wszystkie arkusze w pliku Excel, tworząc osobne pliki CSV dla każdego arkusza. Nazwy arkuszy są zachowane w nazwach plików, co ułatwia identyfikację źródła każdego pliku CSV. IronXL obsługuje różne formaty Excel, w tym XLSX, XLS, XLSM i XLTX, zapewniając szeroką kompatybilność z różnymi wersjami Excel i przypadkami użycia. Więcej informacji na temat konwersji między formatami można znaleźć w dokumentacji.
Oprócz podstawowego tworzenia plików CSV, IronXL oferuje zaawansowane funkcje do obsługi złożonych scenariuszy, które często pojawiają się w środowiskach produkcyjnych. Te możliwości wyróżniają go spośród prostych metod zapisywania plików.
W przypadku znaków specjalnych IronXL automatycznie zajmuje się ich escapowaniem i kodowaniem:
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
// Data with special characters
sheet["A1"].Value = "Company \"ABC\", Inc."; // Quotes
sheet["B1"].Value = "Line 1\nLine 2"; // Newlines
sheet["C1"].Value = "Price: €50,00"; // Unicode characters
workbook.SaveAsCsv("special_chars.csv");Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
' Data with special characters
sheet("A1").Value = "Company ""ABC"", Inc." ' Quotes
sheet("B1").Value = "Line 1" & vbLf & "Line 2" ' Newlines
sheet("C1").Value = "Price: €50,00" ' Unicode characters
workbook.SaveAsCsv("special_chars.csv")IronXL poprawnie zamienia znaki cudzysłowu, obsługuje treści wielowierszowe i zachowuje znaki Unicode. Ta automatyczna obsługa zapobiega typowym błędom parsowania plików CSV, które występują przy ręcznej manipulacji ciągami znaków.
W przypadku przetwarzania wsadowego można efektywnie obsługiwać wiele plików:
string[] sourceFiles = Directory.GetFiles("input_folder", "*.xlsx");
foreach (string file in sourceFiles)
{
WorkBook wb = WorkBook.Load(file);
var csv = Path.ChangeExtension(file, ".csv");
wb.SaveAsCsv(csv);
}Imports System.IO
Dim sourceFiles As String() = Directory.GetFiles("input_folder", "*.xlsx")
For Each file As String In sourceFiles
Dim wb As WorkBook = WorkBook.Load(file)
Dim csv = Path.ChangeExtension(file, ".csv")
wb.SaveAsCsv(csv)
NextWydajność pamięci ma kluczowe znaczenie podczas przetwarzania dużych zbiorów danych. IronXL optymalizuje wykorzystanie pamięci wewnętrznie, ale można jeszcze bardziej poprawić wydajność, przetwarzając dane w partiach i odpowiednio zwalniając zasoby:
WorkBook largeWorkbook = WorkBook.Create();
WorkSheet sheet = largeWorkbook.CreateWorkSheet("LargeData");
// Process in batches
const int batchSize = 1000;
for (int batch = 0; batch < 10; batch++)
{
for (int row = 0; row < batchSize; row++)
{
int actualRow = (batch * batchSize) + row;
sheet.SetCellValue(actualRow, 0, $"Row {actualRow}");
// Add more data...
sheet.SetCellValue(actualRow, 1, DateTime.Now);
sheet.SetCellValue(actualRow, 2, $"Batch {batch + 1}");
}
}
largeWorkbook.SaveAsCsv("large_dataset.csv");Dim largeWorkbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = largeWorkbook.CreateWorkSheet("LargeData")
' Process in batches
Const batchSize As Integer = 1000
For batch As Integer = 0 To 9
For row As Integer = 0 To batchSize - 1
Dim actualRow As Integer = (batch * batchSize) + row
sheet.SetCellValue(actualRow, 0, $"Row {actualRow}")
' Add more data...
sheet.SetCellValue(actualRow, 1, DateTime.Now)
sheet.SetCellValue(actualRow, 2, $"Batch {batch + 1}")
Next
Next
largeWorkbook.SaveAsCsv("large_dataset.csv")
IronXL zmienia zarządzanie plikami CSV w języku C# z żmudnego zadania w prosty proces. Dzięki zapewnieniu ujednoliconego interfejsu API zarówno dla operacji CSV, jak i Excel, eliminuje to potrzebę stosowania wielu bibliotek lub złożonej logiki parsowania. Automatyczna obsługa znaków specjalnych, typów danych i kwestii związanych z kodowaniem przez bibliotekę zapewnia niezawodny eksport danych między różnymi systemami i lokalizacjami.
Niezależnie od tego, czy tworzysz systemy raportowania, potoki integracji danych, czy proste funkcje eksportu, IronXL zapewnia narzędzia niezbędne do wydajnego zarządzania plikami CSV. Jego kompatybilność z istniejącymi plikami Excel i strukturami DataTable ułatwia integrację z istniejącymi aplikacjami bez konieczności przeprowadzania gruntownej refaktoryzacji. Po wygenerowaniu plików CSV można je otworzyć bezpośrednio w programie Excel lub sprawdzić ich surowy format za pomocą dowolnego edytora tekstu w celu szybkiej weryfikacji lub rozwiązywania problemów.
Chcesz usprawnić operacje związane z plikami CSV? Zacznij od darmowej wersji próbnej lub eksploruj kompleksową dokumentację API, aby odkryć bardziej zaawansowane funkcje. Dla wdrożeń produkcyjnych, licencjonowanie zaczyna się od $999 i obejmuje profesjonalne wsparcie oraz aktualizacje.
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.
