Ikona wiadomości
Przejdź do treści stopki
  1. IronXL
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Blog „Zapisywanie w formacie CSV w języku C#”
KORZYSTANIE Z IRONXL

Jak zapisać dane w formacie CSV w języku C# przy użyciu IronXL

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Managing CSV Files with IronXL in C

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 simplifies this entire process by providing a comprehensive API that handles CSV operations, such as C# save to CSV, alongside full Excel compatibility.

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.

C# Save to CSV Format Using IronXL: Image 1 - IronXL

Pierwsze kroki z IronXL

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.

C# Save to CSV Format Using IronXL: Image 2 - Cross Platform

Otwórz Visual Studio, przejdź do konsoli menedżera pakietów i wpisz następujące polecenie:

// Install via Package Manager Console
Install-Package IronXl.Excel
// Install via Package Manager Console
Install-Package IronXl.Excel
$vbLabelText   $csharpLabel

C# Save to CSV Format Using IronXL: Image 3 - Installation

// Or via .NET CLI
dotnet add package IronXl.Excel
// Or via .NET CLI
dotnet add package IronXl.Excel
$vbLabelText   $csharpLabel

Once installed, add the IronXL namespace to your C# file to access all the CSV management features, such as write data:

using IronXL;
using IronXL;
Imports IronXL
$vbLabelText   $csharpLabel

Ta 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 skomplikówanej 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.

Jak zapisywać i zapisywać dane do nowych plików CSV?

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; }
}
// 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 Class
$vbLabelText   $csharpLabel

Moż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!");
    }
}
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 Class
$vbLabelText   $csharpLabel

Wyjaśnienie:

  1. Klasa publiczna student definiuje schemat modelu danych.
  2. Tworzona jest lista obiektów typu Student z przykładowymi danymi.
  3. IronXL's WorkBook and WorkSheet APIs are used to create a structured spreadsheet in memory.
  4. Nagłówki są dodawane ręcznie, aby zapewnić czytelność w pliku wyjściowym CSV.
  5. Dane dotyczące uczniów są zapisywane warkuszach po jednym wierszu.
  6. Finally, the data is saved as a CSV file using SaveAsCsv().

Wynik

C# Save to CSV Format Using IronXL: Image 4 - Console Output

C# Save to CSV Format Using IronXL: Image 5 - Excel Output

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 (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 Try
$vbLabelText   $csharpLabel

Dzię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");
}
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");
}
$vbLabelText   $csharpLabel

Ten kod tworzy ustrukturyzowany skoroszyt z nagłówkami i danymi, a następnie eksportuje go do formatu CSV. The WorkBook.Create() method initializes a new spreadsheet in memory. 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. When you call SaveAsCsv(), IronXL automatically handles the conversion, properly escaping any special characters and maintaining data integrity.

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.

Wynik

C# Save to CSV Format Using IronXL: Image 6 - CSV Output

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", ";");
// Save with semicolon delimiter for European locale compatibility
workbook.SaveAsCsv("sales_report.csv", ";");
$vbLabelText   $csharpLabel 
// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");
// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");
' Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", vbTab)
$vbLabelText   $csharpLabel

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.

C# Save to CSV Format Using IronXL: Image 7 - Features

Jak wyeksportować tabelę danych do pliku CSV?

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");
// 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")
$vbLabelText   $csharpLabel

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.

Wynik

C# Save to CSV Format Using IronXL: Image 8 - DataTable to CSV Output

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
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")
$vbLabelText   $csharpLabel

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 warunkówego lub zmienić układ kolumn. Dokumentacja IronXL zawiera obszerne przykłady zaawansowanych scenariuszy manipulacji tabelami danych (DataTable).

Jak przekonwertować pliki Excel do formatu CSV?

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
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")
$vbLabelText   $csharpLabel

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.

Dane wejściowe

C# Save to CSV Format Using IronXL: Image 9 - Sample Input

Wynik

C# Save to CSV Format Using IronXL: Image 10 - Excel to CSV Output

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}");
}
// 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}")
Next
$vbLabelText   $csharpLabel

Ten 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.

Zaawansowane techniki zarządzania plikami CSV

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");
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")
$vbLabelText   $csharpLabel

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.

Wynik

C# Save to CSV Format Using IronXL: Image 11 - Special Characters Output

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);
}
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)
Next
$vbLabelText   $csharpLabel

Wydajność 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");
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")
$vbLabelText   $csharpLabel

Wynik

C# Save to CSV Format Using IronXL: Image 12 - Large Dataset Output

Wnioski

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? Start with a free trial or explore the comprehensive API documentation to discover more advanced features. For production deployments, licensing starts at $799 and includes professional support and updates.

C# Save to CSV Format Using IronXL: Image 13 - Licensing

Często Zadawane Pytania

Czym jest IronXL?

IronXL to potężna biblioteka C#, która pozwala programistom na odczytywanie, edytowanie i tworzenie plików Excel oraz CSV w ramach aplikacji .NET.

Jak mogę zapisać dane w formacie CSV za pomocą IronXL?

Możesz zapisać dane w formacie CSV za pomocą IronXL, ładując je do skoroszytu IronXL, a następnie używając metody „SaveAs” do wyeksportowania ich jako plik CSV.

Jakie są zalety korzystania z IronXL do zarządzania plikami CSV?

IronXL zapewnia wydajny sposób zarządzania plikami CSV, oferując takie funkcje, jak łatwa obróbka plików, import/eksport danych oraz kompatybilność z różnymi aplikacjami .NET.

Czy IronXL radzi sobie z dużymi zbiorami danych podczas zapisywania do plików CSV?

Tak, IronXL został zaprojektowany do wydajnej obsługi dużych zbiorów danych, dzięki czemu nadaje się do zapisywania obszernych zbiorów danych w formacie CSV.

Czy za pomocą IronXL można konwertować pliki Excel do formatu CSV?

Tak, IronXL umożliwia konwersję plików Excel do formatu CSV poprzez załadowanie pliku Excel do skoroszytu i użycie metody „SaveAs” w celu wyeksportowania go jako plik CSV.

Z jakim językiem programowania jest kompatybilny IronXL?

IronXL jest kompatybilny z językiem C# i został zaprojektowany tak, aby płynnie integrować się z aplikacjami .NET.

Czy IronXL obsługuje zarówno odczyt, jak i zapis plików CSV?

Tak, IronXL obsługuje zarówno odczyt, jak i zapis plików CSV, zapewniając kompleksowe rozwiązanie do zarządzania plikami CSV.

Czy istnieją jakieś wymagania wstępne dotyczące korzystania z IronXL w projekcie C#?

Aby używać IronXL w projekcie C#, musisz mieć zainstalowany .NET Framework, a IronXL można łatwo zintegrować, instalując go za pośrednictwem NuGet.

Czy IronXL może być używany do analizy danych w plikach CSV?

Tak, IronXL może być wykorzystywany do analizy danych, umożliwiając programowe przetwarzanie i wyszukiwanie danych w plikach CSV.

Jakie rodzaje aplikacji mogą skorzystać z funkcji CSV IronXL?

Każda aplikacja .NET wymagająca wydajnego zarządzania danymi CSV, taka jak narzędzia do przetwarzania danych, systemy raportowania i aplikacje Enterprise, może skorzystać z IronXL.

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