Jaka jest zaleta korzystania z IronXL do zapisywania danych w formacie CSV w języku C#?

IronXL zapewnia kompleksowy interfejs API, który upraszcza obsługę operacji CSV, w tym zapisywanie danych do plików CSV, a jednocześnie oferuje pełną kompatybilność z programem Excel, ułatwiając zarządzanie znakami specjalnymi, wieloma typami danych i dużymi zbiorami danych.

W jaki sposób IronXL obsługuje znaki specjalne w plikach CSV?

IronXL efektywnie zarządza znakami specjalnymi w plikach CSV, zapewniając solidne możliwości analizowania i zapisywania, co gwarantuje zachowanie integralności danych podczas operacji na plikach.

Czy IronXL może obsługiwać duże zbiory danych podczas zapisywania do plików CSV?

Tak, IronXL został zaprojektowany do wydajnej obsługi dużych zbiorów danych, zapewniając zoptymalizowane pod kątem wydajności podejście do zapisywania danych w plikach CSV bez utraty szybkości lub niezawodności.

Czy IronXL obsługuje wiele typów danych w operacjach CSV?

IronXL obsługuje wiele typów danych, umożliwiając programistom płynny eksport złożonych zbiorów danych do formatu CSV bez napotykania problemów z kompatybilnością typów danych.

Czy IronXL jest kompatybilny z Excelem podczas obsługi plików CSV?

IronXL oferuje pełną kompatybilność z Excelem, co oznacza, że oprócz operacji w Excelu może obsługiwać pliki CSV, co czyni go wszechstronnym narzędziem dla programistów pracujących z danymi z arkuszy kalkulacyjnych.

Co sprawia, że IronXL jest solidnym rozwiązaniem do zarządzania plikami CSV w języku C#?

Solidne rozwiązanie IronXL do zarządzania plikami CSV wynika z jego kompleksowego API, które upraszcza złożone operacje na plikach CSV i zapewnia dodatkowe funkcje, takie jak kompatybilność z Excelem oraz obsługę dużych zbiorów danych.

W jaki sposób IronXL upraszcza proces zapisywania do pliku CSV w języku C#?

IronXL upraszcza ten proces poprzez wyeliminowanie złożoności związanej z zarządzaniem plikami CSV, zapewniając programistom proste metody efektywnego zapisywania danych w formacie CSV.

What error handling features does IronXL offer when creating CSV files?

IronXL allows you to handle file I/O errors, such as file locks or invalid paths, using try-catch blocks to ensure your application remains robust during CSV creation.

Can I use formulas in my spreadsheet before exporting to CSV with IronXL?

Yes, IronXL evaluates formulas automatically during the export process, ensuring that CSV files contain the calculated values rather than the formula text.

What kinds of data can be managed within a CSV using IronXL?

IronXL can manage various data types, including strings, integers, decimals, and dates. It ensures proper formatting and data integrity in the resulting CSV file.

Biblioteka Excel dla C#

Explore Biblioteka IronXL Excel dla C# .NET Bezpłatna próba

Czytaj pliki Excel bez Interop

Zobacz wszystkie przykłady kodu %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

KORZYSTANIE Z IRONXL

Jak zapisać dane do pliku CSV w języku C# za pomocą IronXL

Curtis Chau

Updated: 18 czerwca 2026

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, udostępniając kompleksowy interfejs API, który obsługuje operacje CSV, takie jak zapis do pliku CSV w języku C#, a także zapewnia pełną kompatybilność z programem Excel.

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.

Jak zapisać dane do CSV w C# z IronXL: Ilustracja 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.

Jak zapisać dane do CSV w C# z IronXL: Ilustracja 2 - Platforma wielosystemowa

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

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Jak zapisać dane do CSV w C# z IronXL: Ilustracja 3 - Instalacja

Lub za pomocą .NET CLI:

> dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Po zainstalowaniu dodaj przestrzeń nazw IronXL do pliku C#, aby uzyskać dostęp do wszystkich funkcji zarządzania plikami CSV, takich jak zapis danych:

using IronXL;

using IronXL;

Imports IronXL

Imports IronXL

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

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 string firstname, public string lastname
    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 string firstname, public string lastname
    public int Age { get; set; }
    public string? Grade { get; set; }
}

Option Strict On
Option Infer On

Public Class Student
    Public Property Name As String
    Public Property Age As Integer
    Public Property Grade As String
End Class

Option Strict On
Option Infer On

Public Class Student
    Public Property Name As String
    Public Property Age As Integer
    Public Property Grade As String
End Class

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

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

Wyjaśnienie:

Klasa publiczna student definiuje schemat modelu danych.
Tworzona jest lista obiektów typu Student z przykładowymi danymi.
Interfejsy API WorkBook i WorkSheet firmy IronXL służą do tworzenia ustrukturyzowanych arkuszy kalkulacyjnych w pamięci.
Nagłówki są dodawane ręcznie, aby zapewnić czytelność w pliku wyjściowym CSV.
Dane dotyczące uczniów są zapisywane warkuszach po jednym wierszu.
Na koniec dane są zapisywane jako plik CSV za pomocą funkcji SaveAsCsv().

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 4 - Wyjście konsoli

Jak zapisać dane do CSV w C# z IronXL: Rysunek 5 - Wyjście Excel

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

Try
    workbook.SaveAsCsv("students.csv")
Catch ex As Exception
    Console.WriteLine($"Error occurred while saving CSV: {ex.Message}")
End Try

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");
}

net

net

Ten kod tworzy ustrukturyzowany skoroszyt z nagłówkami i danymi, a następnie eksportuje go do formatu CSV. Metoda WorkBook.Create() inicjuje 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. Po wywołaniu funkcji SaveAsCsv() biblioteka IronXL automatycznie zajmuje się konwersją, odpowiednio zamieniając 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.

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 6 - Wyjście CSV

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 tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");

// Save with semicolon delimiter for European locale compatibility
workbook.SaveAsCsv("sales_report.csv", ";");
// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");

net

net

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.

Jak zapisać dane do CSV w C# z IronXL: Rysunek 7 - Funkcje

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")

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.

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 8 - DataTable do wyjścia 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
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")

' 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).

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")

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

Dane wejściowe

Jak zapisać dane do CSV w C# z IronXL: Rysunek 9 - Przykładowe wejście

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 10 - Wyjście z Excel do 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}");
}

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

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

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")

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.

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 11 - Wyjście znaków specjalnych

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

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

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")

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")

Wynik

Jak zapisać dane do CSV w C# z IronXL: Rysunek 12 - Wyjście dużego zbioru danych

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? Zacznij od bezpłatnej wersji próbnej, która obejmuje profesjonalne wsparcie i aktualizacje.

Curtis Chau

Czat z zespołem inżynierów teraz

Autor tekstów technicznych

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.

...

Czytaj więcej