Was ist der Vorteil der Verwendung von IronXL zum Speichern von Daten als CSV in C#?

IronXL bietet eine umfassende API, die das Handling von CSV-Operationen vereinfacht, einschließlich der Speicherung von Daten als CSV, und voll kompatibel mit Excel ist, wodurch die Verwaltung von Sonderzeichen, mehreren Datentypen und großen Datensätzen erleichtert wird.

Wie handhabt IronXL Sonderzeichen in CSV-Dateien?

IronXL verwaltet Sonderzeichen in CSV-Dateien effizient, indem es robuste Parsing- und Schreibfähigkeiten bietet und sicherstellt, dass die Datenintegrität während der Dateioperationen gewahrt bleibt.

Kann IronXL große Datensätze beim Speichern in CSV verwalten?

Ja, IronXL ist dafür konzipiert, große Datensätze effizient zu verwalten und bietet einen leistungsoptimierten Ansatz zum Speichern von Daten in CSV-Dateien, ohne Geschwindigkeit oder Zuverlässigkeit zu beeinträchtigen.

Unterstützt IronXL mehrere Datentypen für CSV-Operationen?

IronXL unterstützt mehrere Datentypen, sodass Entwickler komplexe Datensätze nahtlos im CSV-Format exportieren können, ohne auf Probleme mit der Datentypkompatibilität zu stoßen.

Ist IronXL kompatibel mit Excel, wenn es um die Handhabung von CSV-Dateien geht?

IronXL bietet volle Excel-Kompatibilität, was bedeutet, dass es CSV-Dateien zusammen mit Excel-Operationen handhaben kann, was es zu einem vielseitigen Werkzeug für Entwickler macht, die mit Tabellenkalenderdaten arbeiten.

Was macht IronXL zu einer robusten Lösung für die Verwaltung von CSV-Dateien in C#?

Die robuste Lösung von IronXL für die Verwaltung von CSV-Dateien ergibt sich aus seiner umfassenden API, die komplexe CSV-Operationen vereinfacht und zusätzliche Funktionen wie Excel-Kompatibilität und Unterstützung für große Datensätze bietet.

Wie vereinfacht IronXL den Prozess des Speicherns in CSV in C#?

IronXL vereinfacht den Prozess, indem es die Komplexität der CSV-Dateiverwaltung abstrahiert und Entwicklern einfache Methoden bietet, um Daten effizient in CSV zu speichern.

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.

Die C# Excel-Bibliothek

Explore IronXL Excel Spreadsheet Library for C# .NET Gratis testen

Excel-Dateien ohne Interop lesen

Alle Codebeispiele anzeigen

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

IRONXL VERWENDEN

Wie man Daten mit IronXL in C# als CSV speichert

Curtis Chau

Updated: 18. Juni 2026

Die Verwaltung von CSV-Dateien ist eine grundlegende Anforderung in modernen C#-Anwendungen, von der Erstellung von Geschäftsberichten bis hin zur Exportierung von Datenbankeinträgen. Während .NET grundlegende Datei-Schreibfunktionen bietet, erfordert die effiziente Handhabung von CSV-Dateien, insbesondere wenn es um Sonderzeichen, verschiedene Datentypen und große Datenmengen geht, eine robustere Lösung. IronXL vereinfacht diesen gesamten Prozess, indem es eine umfassende API bereitstellt, die CSV-Operationen, wie das Speichern in CSV in C#, zusammen mit voller Excel-Kompatibilität handhabt.

Dieses Tutorial zeigt, wie man die leistungsstarken Funktionen von IronXL nutzen kann, um CSV-Dateien in Ihren C#-Anwendungen zu erstellen, zu speichern und zu verwalten. Sie lernen praktische Techniken zum Umgang mit verschiedenen Datenquellen kennen, von einfachen Sammlungen bis hin zu komplexen DataTables, und das alles bei sauberem und wartbarem Code.

Wie speichert man Daten in CSV in C# mit IronXL: Bild 1 - IronXL

Erste Schritte mit IronXL

Bevor Sie in CSV-Operationen eintauchen, müssen Sie IronXL in Ihrem Projekt installieren. Die Bibliothek unterstützt .NET Framework 4.6.2+ und .NET Core 2+, was sie mit sowohl älteren als auch modernen Anwendungen kompatibel macht. IronXL bietet auch exzellente plattformübergreifende Unterstützung und läuft nahtlos unter Windows, Linux und macOS.

Wie speichert man Daten in CSV in C# mit IronXL: Bild 2 - Plattformübergreifend

Öffnen Sie Visual Studio, gehen Sie zur Paket-Manager-Konsole und geben Sie den folgenden Befehl ein:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Wie speichert man Daten in CSV in C# mit IronXL: Bild 3 - Installation

Oder über die .NET CLI:

> dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Nach der Installation fügen Sie den IronXL-Namespace zu Ihrer C#-Datei hinzu, um auf alle CSV-Verwaltungsfunktionen zuzugreifen, wie z.B. das Schreiben von Daten:

using IronXL;

using IronXL;

Imports IronXL

Imports IronXL

Diese einfache Einrichtung gibt Ihnen sofortigen Zugriff auf leistungsstarke Tabellenkalkulationsmanipulationsmöglichkeiten. Im Gegensatz zu traditionellen Ansätzen, die Excel Interop oder komplexe CSV-Parsing-Logik erfordern, bietet IronXL eine intuitive API, die die Komplexität im Hintergrund handhabt. Die Bibliothek operiert unabhängig ohne die Notwendigkeit einer Microsoft Office Installation, was sie ideal für Serverbereitstellungen und containerisierte Anwendungen macht.

Wenn beim Installieren oder Initialisieren der Bibliothek ein Fehler auftritt, stellen Sie sicher, dass Ihr Projekt eine unterstützte .NET-Version anvisiert und dass alle Abhängigkeiten korrekt wiederhergestellt sind.

Wie speichert und schreibt man Daten in neue CSV-Dateien?

Das Erstellen oder Schreiben von CSV-Dateien von Grund auf mit IronXL folgt einem intuitiven Muster. Sie beginnen mit der Erstellung eines Arbeitsbuchs, fügen alle Daten zu den Zellen hinzu und speichern es dann im CSV-Format. Dieser Ansatz bietet viel mehr Kontrolle als grundlegende Methoden der Zeichenkettenverkettung.

Bevor Sie in die Hauptlogik der CSV-Erstellung eintauchen, hier eine einfache Modelldefinition mit einer öffentlichen Klassenstruktur für Studenten. Dieses Modell repräsentiert strukturierte Daten, die wir später in CSV exportieren können.

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

Sie können eine Liste von Studentenobjekten füllen und dann IronXL verwenden, um diese effizient in eine CSV-Datei zu exportieren. Dieses Beispiel zeigt, wie man Klassenattribute Zellen in Arbeitsblättern zuordnet:

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

Erläuterung:

Die öffentliche Klasse student definiert das Schema für Ihr Datenmodell.
Eine Liste von Studentenobjekten wird mit Beispieldaten erstellt.
Die WorkBook- und WorkSheet-APIs von IronXL werden verwendet, um ein strukturiertes Arbeitsblatt im Speicher zu erstellen.
Überschriften werden manuell hinzugefügt, um die Lesbarkeit in der CSV-Ausgabe sicherzustellen.
Die Studentendaten werden Zeile für Zeile in das Arbeitsblatt geschrieben.
Schließlich werden die Daten mit SaveAsCsv() als CSV-Datei gespeichert.

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 4 - Konsolenausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 5 - Excel-Ausgabe

Dieses Muster ist skalierbar; Daher können Sie es leicht für größere Datensätze anpassen oder in eine Anwendung integrieren, die Studentendaten aus einer Datenbank oder API abruft.

Wenn zum Beispiel ein Fehler beim Schreiben in die Datei auftritt (z. B. die Datei ist gesperrt oder der Pfad ist ungültig), können Sie diesen elegant behandeln:

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

Dies stellt sicher, dass Ihre Anwendung robust und informativ bleibt, auch wenn Dateieingabe-/Ausgabeprobleme auftreten.

Der folgende Beispielcode zeigt, wie man eine einfache CSV-Datei erstellt.

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

Dieser Code erstellt ein strukturiertes Arbeitsbuch mit Kopfzeilen und Daten und exportiert es dann im CSV-Format. Die Methode WorkBook.Create() initialisiert eine neue Tabelle im Speicher. Jede Zelle kann verschiedene Datentypen enthalten, wie Zeichenfolgen, Ganzzahlen, Dezimalzahlen und sogar Formeln. Wenn Sie SaveAsCsv() aufrufen, übernimmt IronXL automatisch die Konvertierung und entnimmt ordnungsgemäß Sonderzeichen und stellt die Datenintegrität sicher.

Der Reiz dieses Ansatzes liegt in seiner Flexibilität. Sie können die Daten als Tabellenkalkulation vor dem Export manipulieren und dabei Formeln, Formatierungen oder Validierungsregeln anwenden. IronXL wertet Formeln automatisch während des Exportprozesses aus und stellt sicher, dass Ihr CSV die berechneten Werte anstelle des Formeltextes enthält.

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 6 - CSV-Ausgabe

Für benutzerdefinierte Trennzeichenerfordernisse können Sie mit IronXL Alternativen zum Standardkomma angeben:

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

Diese Flexibilität gewährleistet die Kompatibilität mit verschiedenen regionalen Einstellungen und Anwendungsanforderungen. Die Bibliothek erledigt automatisch die Kodierungsprobleme und stellt sicher, dass Zeichen in verschiedenen Systemen und Regionen korrekt dargestellt werden.

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 7 - Funktionen

Wie exportiert man DataTables in CSV?

DataTables sind allgegenwärtig in .NET-Anwendungen zur Speicherung tabellarischer Daten aus Datenbanken oder Geschäftslogik. IronXL bietet nahtlose DataTable-zu-CSV-Konvertierung und bewahrt dabei die Spaltennamen und Datentypen.

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

Dieses Beispiel zeigt ein Szenario aus der realen Welt, bei dem Bestelldaten aus einer Datenbank für Berichterstattungs- oder Integrationszwecke exportiert werden müssen. Der Code durchläuft die DataTable-Struktur und bewahrt Spaltenüberschriften und Zeilendaten. IronXL übernimmt die Konvertierung verschiedener Datentypen entsprechend und stellt sicher, dass Daten wie Daten, Dezimalzahlen und Zeichenfolgen im resultierenden CSV-Dokument richtig formatiert sind.

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 8 - DataTable zu CSV-Ausgabe

Für komplexere Szenarien, die mehrere zusammenhängende Tabellen oder fortgeschrittene Datenumwandlungen betreffen, können Sie die Zellreferenzierungs- und Formelkapazitäten von IronXL nutzen:

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

Dieser Ansatz bietet viel mehr Kontrolle als traditionelle Exportmethoden für DataTables. Sie können berechnete Felder hinzufügen, logische bedingte Formatierungen anwenden oder Spalten vor dem endgültigen Export neu anordnen. Die IronXL-Dokumentation bietet umfassende Beispiele für fortgeschrittene DataTable-Manipulationsszenarien.

Wie konvertiert man Excel-Dateien in CSV?

Eine der stärksten Funktionen von IronXL ist die Fähigkeit, nahtlos mit bestehenden Excel-Dateien zu arbeiten und diese in das CSV-Format zu konvertieren, während die Datenintegrität bewahrt wird. Dies ist besonders nützlich bei der Integration mit Systemen, die Excel-Berichte erzeugen, aber CSV für die nachfolgende Verarbeitung benötigen.

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

Beim Laden von Excel-Dateien bewahrt IronXL alle Zellwerte, einschließlich derer, die durch Formeln berechnet wurden. Die Bibliothek wertet Excel-Formeln während des Konvertierungsprozesses aus und stellt sicher, dass Ihr CSV die tatsächlich berechneten Werte enthält. Dies beseitigt das häufige Problem, dass Formeln im CSV-Export als Text erscheinen.

Eingabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 9 - Beispieleingabe

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 10 - Excel zu CSV-Ausgabe

Für Arbeitsmappen mit mehreren Blättern behandelt IronXL jedes Blatt intelligent:

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

Dieser Code iteriert durch alle Arbeitsblätter in einer Excel-Datei und erstellt für jedes Blatt separate CSV-Dateien. Die Blattnamen werden in der Dateibenennung beibehalten, was es einfach macht, die Herkunft jeder CSV-Datei zu identifizieren. IronXL unterstützt verschiedene Excel-Formate, einschließlich XLSX, XLS, XLSM und XLTX, und bietet eine breite Kompatibilität mit verschiedenen Excel-Versionen und Anwendungsfällen. Erfahren Sie mehr über das Konvertieren zwischen Formaten in der Dokumentation.

Fortgeschrittene Techniken zur Verwaltung von CSVs

Über die grundlegende CSV-Erstellung hinaus bietet IronXL ausgefeilte Funktionen für den Umgang mit komplexen Szenarien, die oft in Produktionsumgebungen auftreten. Diese Fähigkeiten heben es von einfachen Dateischreibansätzen ab.

Beim Umgang mit Sonderzeichen erledigt IronXL das Escaping und die Kodierung automatisch:

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 escape korrekt Anführungszeichen, behandelt mehrzeiligen Inhalt und bewahrt Unicode-Zeichen. Diese automatische Handhabung verhindert häufige CSV-Parsing-Fehler, die mit manuellen Zeichenkettenmanipulationen auftreten.

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 11 - Ausgabe spezieller Zeichen

Für Szenarien der Stapelverarbeitung können Sie effizient mit mehreren Dateien umgehen:

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

Die Speichereffizienz wird entscheidend, wenn es um die Verarbeitung großer Datenmengen geht. IronXL optimiert den Speicherverbrauch intern, aber Sie können die Leistung weiter verbessern, indem Sie Daten in Blöcken verarbeiten und Ressourcen ordnungsgemäß freigeben:

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

Ausgabe

Wie speichert man Daten in CSV in C# mit IronXL: Abbildung 12 - Große Datensatzausgabe

Abschluss

IronXL verwandelt die Verwaltung von CSV-Dateien in C# von einer mühseligen Aufgabe in einen einfachen Prozess. Durch die Bereitstellung einer einheitlichen API für sowohl CSV als auch Excel-Operationen entfällt das Bedürfnis nach mehreren Bibliotheken oder komplizierter Parsing-Logik. Die automatische Handhabung von Sonderzeichen, Datentypen und Kodierungsproblemen durch die Bibliothek gewährleistet einen zuverlässigen Datenexport über verschiedene Systeme und Regionen hinweg.

Egal, ob Sie Berichtssysteme, Datenintegrationspipelines oder einfache Exportfunktionen entwickeln, IronXL bietet die Werkzeuge, die für eine effiziente CSV-Verwaltung nötig sind. Die Kompatibilität mit vorhandenen Excel-Dateien und DataTable-Strukturen erleichtert die Integration in bestehende Anwendungen ohne größere Umstrukturierungen. Sobald Ihre CSV-Dateien generiert sind, können Sie sie direkt in Excel öffnen oder ihr Rohformat mit jedem Texteditor für schnelle Validierung oder Fehlerbehebung inspizieren.

Bereit, Ihre CSV-Operationen zu optimieren? Starten Sie mit einer kostenlosen Testversion und erhalten Sie professionellen Support und Updates.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

...