Jak zapisać dane do pliku CSV w języku C# za pomocą 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.

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

Install-Package IronXl.Excel

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

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



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

Wyjaśnienie:

1. Klasa publiczna student definiuje schemat modelu danych.
2. Tworzona jest lista obiektów typu Student z przykładowymi danymi.
3. Interfejsy API WorkBook i WorkSheet firmy IronXL służą do tworzenia ustrukturyzowanych arkuszy kalkulacyjnych w pamięci.
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. Na koniec dane są zapisywane jako plik CSV za pomocą funkcji SaveAsCsv().

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

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

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

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

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.

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

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

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.

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

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

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.

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

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

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.