Eksportuj dane SQL do Excel w C# z IronXL

Jak zainstalować IronXL do eksportu danych SQL?

Przed napisaniem jakiegokolwiek kodu należy dodać IronXL do swojego projektu. Najszybszym sposobem jest skorzystanie z konsoli menedżera pakietów NuGet w programie Visual Studio:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Alternatywnie można użyć interfejsu CLI platformy .NET:

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Po zainstalowaniu dodaj wymagańe przestrzenie nazw na początku pliku. Dzięki instrukcjom najwyższego poziomu .NET 10 konfiguracja wygląda następująco:

using IronXL;
using System.Data;
using System.Data.SqlClient;

using IronXL;
using System.Data;
using System.Data.SqlClient;

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

IronXL jest przeznaczony dla .NET Standard 2.0 i nowszych wersji, więc działa z projektami .NET 10, .NET Framework, ASP.NET Core i Blazor bez dodatkowej konfiguracji. Pakiet można znaleźć na NuGet.

Jaki jest najlepszy sposób na eksport danych z bazy danych SQL Server?

Najbardziej efektywne podejście do eksportowania danych z serwera SQL do pliku Excel obejmuje trzy kroki: nawiązanie połączenia z bazą danych, pobranie danych do DataTable oraz zapisanie danych w arkuszu Excel przy użyciu IronXL. W przeciwieństwie do rozwiązań Microsoft Interop, IronXL działa niezależnie i obsługuje duże zbiory danych bez spadków wydajności spowodowanych obciążeniem związanym z interoperacyjnością COM.

Podstawowy wzorzec jest prosty. SqlDataAdapter jest częścią frameworka dostępu do danych ADO.NET firmy Microsoft i od wersji .NET 1.0 stanowi standardowy sposób wypełniania obiektów DataTable z relacyjnych baz danych:

1. Otwórz SqlConnection z ciągiem połączenia
2. Użyj SqlDataAdapter, aby wypełnić DataTable lub DataSet
3. Wywołaj metody IronXL, aby utworzyć skoroszyt i wypełnić komórki arkusza
4. Zapisz skoroszyt jako .xlsx lub .xls

To podejście jest zgodne z SQL Server 2012 i nowszymi wersjami, a także z Azure SQL Database, Amazon RDS dla SQL Server oraz dowolnym źródłem danych zgodnym z ADO.NET. Ten sam schemat ma zastosowanie niezależnie od tego, czy pracujesz z aplikacją konsolową, czy internetowym narzędziem do raportowania.

Jak połączyć się z serwerem SQL i pobrać dane?

Zanim będzie można wyeksportować dane SQL, należy nawiązać połączenie i wykonać zapytanie SQL, aby wypełnić DataTable. Ciąg połączenia zawiera poświadczenia bazy danych SQL Server oraz informacje o serwerze wymagańe do uzyskania dostępu do danych.

Poniższy przykład wysyła zapytanie do tabeli Nierthwind Customers i zapisuje każdy wiersz w arkuszu Excelu przy użyciu interfejsu API IronXL do zapisywania komórek:

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=localhost;Initial Catalog=Nierthwind;Integrated Security=True";
string sql = "SELECT * FROM Customers";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
DataTable dt = new DataTable();
adapter.Fill(dt);

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Customers");

// Write column headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        workSheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
    }
}

workBook.SaveAs("CustomerExport.xlsx");

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=localhost;Initial Catalog=Nierthwind;Integrated Security=True";
string sql = "SELECT * FROM Customers";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
DataTable dt = new DataTable();
adapter.Fill(dt);

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Customers");

// Write column headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        workSheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
    }
}

workBook.SaveAs("CustomerExport.xlsx");

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

Dim connectionString As String = "Data Source=localhost;Initial Catalog=Nierthwind;Integrated Security=True"
Dim sql As String = "SELECT * FROM Customers"

Using connection As New SqlConnection(connectionString)
    connection.Open()

    Dim adapter As New SqlDataAdapter(sql, connection)
    Dim dt As New DataTable()
    adapter.Fill(dt)

    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Customers")

    ' Write column headers
    For col As Integer = 0 To dt.Columns.Count - 1
        workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Next

    ' Write data rows
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            workSheet.SetCellValue(row + 1, col, dt.Rows(row)(col).ToString())
        Next
    Next

    workBook.SaveAs("CustomerExport.xlsx")
End Using

Jak używać LoadWorkSheetsFromDataSet do eksportowania wielu tabel?

Gdy raport wymaga danych z kilku tabel SQL — na przykład z tabel "Produkty" i "Kategorie" — można je załadować do DataSet i pozwolić IronXL automatycznie utworzyć jeden arkusz dla każdej tabeli. Jest to najbardziej zwięzłe podejście do eksportowania zestawu danych (DataSet) lub tabeli danych (DataTable) do programu Excel.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter productsAdapter = new SqlDataAdapter("SELECT * FROM Products", connection);
SqlDataAdapter categoriesAdapter = new SqlDataAdapter("SELECT * FROM Categories", connection);

DataSet dataSet = new DataSet();
productsAdapter.Fill(dataSet, "Products");
categoriesAdapter.Fill(dataSet, "Categories");

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);

workBook.SaveAs("InventoryReport.xlsx");

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter productsAdapter = new SqlDataAdapter("SELECT * FROM Products", connection);
SqlDataAdapter categoriesAdapter = new SqlDataAdapter("SELECT * FROM Categories", connection);

DataSet dataSet = new DataSet();
productsAdapter.Fill(dataSet, "Products");
categoriesAdapter.Fill(dataSet, "Categories");

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);

workBook.SaveAs("InventoryReport.xlsx");

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

Dim connectionString As String = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True"

Using connection As New SqlConnection(connectionString)
    connection.Open()

    Dim productsAdapter As New SqlDataAdapter("SELECT * FROM Products", connection)
    Dim categoriesAdapter As New SqlDataAdapter("SELECT * FROM Categories", connection)

    Dim dataSet As New DataSet()
    productsAdapter.Fill(dataSet, "Products")
    categoriesAdapter.Fill(dataSet, "Categories")

    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)

    workBook.SaveAs("InventoryReport.xlsx")
End Using

Jak można eksportować dane za pomocą przycisku eksportu w ASP.NET?

W przypadku aplikacji internetowych eksport zazwyczaj uruchamia się po kliknięciu przycisku przez użytkownika. Poniższy przykład formularzy internetowych ASP.NET pokazuje, jak obsłużyć zdarzenie kliknięcia przycisku, utworzyć skoroszyt programu Excel na podstawie zapytania SQL oraz przesłać plik do przeglądarki jako plik do pobrania przy użyciu Response.AddHeader:

using IronXL;
using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI;

public partial class ExportPage : Page
{
    private void ExportButton_Click(object sender, EventArgs e)
    {
        string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";

        using SqlConnection connection = new SqlConnection(connectionString);
        SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Orders", connection);
        DataSet dataSet = new DataSet();
        adapter.Fill(dataSet);

        WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);

        byte[] fileBytes = workBook.ToByteArray();
        string filename = "OrdersExport.xlsx";

        Response.Clear();
        Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        Response.AddHeader("content-disposition", "attachment;filename=" + filename);
        Response.BinaryWrite(fileBytes);
        Response.End();
    }
}

using IronXL;
using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI;

public partial class ExportPage : Page
{
    private void ExportButton_Click(object sender, EventArgs e)
    {
        string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";

        using SqlConnection connection = new SqlConnection(connectionString);
        SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Orders", connection);
        DataSet dataSet = new DataSet();
        adapter.Fill(dataSet);

        WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);

        byte[] fileBytes = workBook.ToByteArray();
        string filename = "OrdersExport.xlsx";

        Response.Clear();
        Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        Response.AddHeader("content-disposition", "attachment;filename=" + filename);
        Response.BinaryWrite(fileBytes);
        Response.End();
    }
}

Imports IronXL
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports System.Web.UI

Public Partial Class ExportPage
    Inherits Page

    Private Sub ExportButton_Click(sender As Object, e As EventArgs)
        Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"

        Using connection As New SqlConnection(connectionString)
            Dim adapter As New SqlDataAdapter("SELECT * FROM Orders", connection)
            Dim dataSet As New DataSet()
            adapter.Fill(dataSet)

            Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)

            Dim fileBytes As Byte() = workBook.ToByteArray()
            Dim filename As String = "OrdersExport.xlsx"

            Response.Clear()
            Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
            Response.AddHeader("content-disposition", "attachment;filename=" & filename)
            Response.BinaryWrite(fileBytes)
            Response.End()
        End Using
    End Sub
End Class

Jak dodać formatowanie i nagłówki kolumn do eksportowanych plików Excel?

Surowe eksporty SQL często wymagają poprawek w zakresie prezentacji przed udostępnieniem ich użytkownikom końcowym. IronXL zapewnia kontrolę nad stylami komórek, szerokością kolumn i formatami liczb po zapisaniu danych w arkuszu. Poniższy przykład pokazuje, jak pogrubić wiersz nagłówka i automatycznie dopasować szerokość kolumn:

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter adapter = new SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection);
DataTable dt = new DataTable();
adapter.Fill(dt);

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Orders");

// Write and style header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    workSheet[0, col].Style.Font.Bold = true;
    workSheet[0, col].Style.Font.Height = 12;
}

// Write data rows with type-aware value assignment
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object value = dt.Rows[row][col];
        if (value is DateTime date)
            workSheet.SetCellValue(row + 1, col, date.ToString("yyyy-MM-dd"));
        else if (value is decimal || value is double || value is int)
            workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value));
        else
            workSheet.SetCellValue(row + 1, col, value.ToString());
    }
}

workBook.SaveAs("FormattedOrdersExport.xlsx");

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

SqlDataAdapter adapter = new SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection);
DataTable dt = new DataTable();
adapter.Fill(dt);

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Orders");

// Write and style header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    workSheet[0, col].Style.Font.Bold = true;
    workSheet[0, col].Style.Font.Height = 12;
}

// Write data rows with type-aware value assignment
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object value = dt.Rows[row][col];
        if (value is DateTime date)
            workSheet.SetCellValue(row + 1, col, date.ToString("yyyy-MM-dd"));
        else if (value is decimal || value is double || value is int)
            workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value));
        else
            workSheet.SetCellValue(row + 1, col, value.ToString());
    }
}

workBook.SaveAs("FormattedOrdersExport.xlsx");

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"

Using connection As New SqlConnection(connectionString)
    connection.Open()

    Dim adapter As New SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection)
    Dim dt As New DataTable()
    adapter.Fill(dt)

    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Orders")

    ' Write and style header row
    For col As Integer = 0 To dt.Columns.Count - 1
        workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        workSheet(0, col).Style.Font.Bold = True
        workSheet(0, col).Style.Font.Height = 12
    Next

    ' Write data rows with type-aware value assignment
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            Dim value As Object = dt.Rows(row)(col)
            If TypeOf value Is DateTime Then
                Dim dateValue As DateTime = CType(value, DateTime)
                workSheet.SetCellValue(row + 1, col, dateValue.ToString("yyyy-MM-dd"))
            ElseIf TypeOf value Is Decimal OrElse TypeOf value Is Double OrElse TypeOf value Is Integer Then
                workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value))
            Else
                workSheet.SetCellValue(row + 1, col, value.ToString())
            End If
        Next
    Next

    workBook.SaveAs("FormattedOrdersExport.xlsx")
End Using

Stylizacja wiersza nagłówka pogrubioną czcionką i większym rozmiarem sprawia, że eksportowane raporty są łatwiejsze do odczytania w programie Excel. W przypadku kolumn liczbowych, takich jak sumy lub liczby, przekazanie wartości double zamiast ciągu znaków umożliwia prawidłowe działanie natywnych funkcji sortowania i agregacji programu Excel na wyeksportowanych danych.

Pełen zakres opcji formatowania — w tym obramowania komórek, kolory tła i maski formatowania liczb — można znaleźć w dokumentacji dotyczącej formatowania komórek w IronXL.

Jak efektywnie radzić sobie z dużymi zbiorami danych SQL?

W przypadku tabel zawierających dziesiątki tysięcy wierszy zarządzanie pamięcią staje się istotne. W przypadku większości raportów dobrze sprawdza się wczytanie całego zestawu wyników do DataTable przed zapisaniem do Excela, ale w przypadku bardzo dużych eksportów można przetwarzać wiersze partiami lub używać bezpośrednio SqlDataReader.

W przypadku pracy z eksportami o dużej objętości warto rozważyć następujące strategie:

• Paginacja za pomocą SQL OFFSET/FETCH: Podziel duże eksporty na wiele arkuszy, z których każdy zawiera jedną stronę wyników. Dzięki temu rozmiary poszczególnych arkuszy w programie Excel pozostają łatwe do zarządzania.
• Strumieniowanie na dysk: Wywołaj workBook.SaveAs(filePath) po każdej partii zamiast przechowywać wszystko w pamięci za pomocą ToByteArray().
• Ogranicz wybrane kolumny: Użyj wyraźnych list kolumn w instrukcji SELECT zamiast SELECT *, aby zmniejszyć ilość danych przesyłanych z serwera SQL.

Aby uzyskać wskazówki dotyczące najszybszego sposobu eksportowania tabeli danych (DataTable) do programu Excel w języku C#, na blogu IronXL znajduje się specjalny artykuł porównawczy, w którym zestawiono różne podejścia i ich profile pamięciowe.

Metoda WorkBook.LoadWorkSheetsFromDataSet jest szczególnie wydajna w przypadku obiektów DataSet średniej wielkości, ponieważ wewnętrznie obsługuje iterację wierszy. W przypadku konkretnego scenariusza eksportu z DataTable do Excela metoda ta ogranicza ilość kodu szablonowego i jest zoptymalizowana pod kątem zapisów zbiorczych.

Jak zaimportować dane z powrotem z Excela do SQL Servera?

W przypadku wielu aplikacji do raportowania proces eksportu to tylko połowa sukcesu. Może być również konieczne umożliwienie użytkownikom pobrania szablonu, wypełnienia go danymi i ponownego przesłania do serwera SQL. IronXL sprawia, że ten dwukierunkowy przepływ pracy jest prosty.

Aby zaimportować dane z Excela do bazy danych, załaduj przesłany plik za pomocą WorkBook.Load(filePath), przejdź przez wiersze arkusza i wstaw każdy wiersz, używając spersonalizowanego SqlCommand:

using IronXL;
using System.Data.SqlClient;

WorkBook workBook = WorkBook.Load("UploadedData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

string connectionString = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

// Skip header row, start at row index 1
for (int row = 1; row <= sheet.RowCount; row++)
{
    string productName = sheet[row, 0].StringValue;
    int quantity = (int)sheet[row, 1].DoubleValue;
    decimal price = (decimal)sheet[row, 2].DoubleValue;

    using SqlCommand cmd = new SqlCommand(
        "INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)",
        connection);
    cmd.Parameters.AddWithValue("@name", productName);
    cmd.Parameters.AddWithValue("@qty", quantity);
    cmd.Parameters.AddWithValue("@price", price);
    cmd.ExecuteNienQuery();
}

using IronXL;
using System.Data.SqlClient;

WorkBook workBook = WorkBook.Load("UploadedData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

string connectionString = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True";

using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

// Skip header row, start at row index 1
for (int row = 1; row <= sheet.RowCount; row++)
{
    string productName = sheet[row, 0].StringValue;
    int quantity = (int)sheet[row, 1].DoubleValue;
    decimal price = (decimal)sheet[row, 2].DoubleValue;

    using SqlCommand cmd = new SqlCommand(
        "INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)",
        connection);
    cmd.Parameters.AddWithValue("@name", productName);
    cmd.Parameters.AddWithValue("@qty", quantity);
    cmd.Parameters.AddWithValue("@price", price);
    cmd.ExecuteNienQuery();
}

Imports IronXL
Imports System.Data.SqlClient

Dim workBook As WorkBook = WorkBook.Load("UploadedData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

Dim connectionString As String = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True"

Using connection As New SqlConnection(connectionString)
    connection.Open()

    ' Skip header row, start at row index 1
    For row As Integer = 1 To sheet.RowCount
        Dim productName As String = sheet(row, 0).StringValue
        Dim quantity As Integer = CInt(sheet(row, 1).DoubleValue)
        Dim price As Decimal = CDec(sheet(row, 2).DoubleValue)

        Using cmd As New SqlCommand("INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)", connection)
            cmd.Parameters.AddWithValue("@name", productName)
            cmd.Parameters.AddWithValue("@qty", quantity)
            cmd.Parameters.AddWithValue("@price", price)
            cmd.ExecuteNonQuery()
        End Using
    Next
End Using

Zapytania parametryzowane chronią przed atakami typu SQL injection podczas odczytu danych z plików Excel dostarczonych przez użytkownika. Dokumentacja SqlCommand w serwisie Microsoft Learn obejmuje wszystkie dostępne przeciążenia i wzorce wiązania parametrów. Zawsze sprawdzaj wartości komórek przed wstawieniem — szukaj pustych ciągów znaków, liczb poza zakresem oraz nieoczekiwanych typów danych, które mogą spowodować naruszenie ograniczeń w tabeli SQL Server.

W przypadku odwrotnego kierunku IronXL obsługuje również odczyt plików CSV w języku C# w sytuacjach, gdy źródło danych generuje dane rozdzielone przecinkami zamiast plików .xlsx.

Jak wypada IronXL na tle innych rozwiązań do eksportu?

Istnieje kilka metod eksportowania danych SQL do programu Excel w środowisku .NET. Poniższa tabela podsumowuje kluczowe kompromisy:

Microsoft Interop wymaga zainstalowania pakietu Office na serwerze i nie jest obsługiwany w aplikacjach internetowych po stronie serwera. IronXL, EPPlus i NPOI działają bez pakietu Office. Zaletą IronXL jest doskonała obsługa DataSet i DataTable poprzez LoadWorkSheetsFromDataSet, co pozwala ograniczyć kod eksportu do kilku wierszy w porównaniu z ręczną iteracją wierszy w innych bibliotekach.

Szczegółowe porównanie można znaleźć w artykułe poświęconym alternatywom dla Microsoft Office Interop.

Jakie są Twoje kolejne kroki?

Eksportowanie danych SQL do Excela przy użyciu języka C# staje się proste dzięki IronXL. Biblioteka eliminuje złożone zależności Interop, zapewniając jednocześnie silne wsparcie dla DataTable, DataSet oraz bezpośredniej integracji z bazami danych. Niezależnie od tego, czy tworzysz aplikacje konsolowe, czy internetowe systemy raportowania z możliwością pobierania plików, IronXL zapewnia niezawodne generowanie plików Excel we wszystkich typach projektów .NET 10.

Aby dalej rozwijać tę wiedzę, zapoznaj się z poniższymi zasobami:

• Tworzenie pliku Excel w języku C# — kompletny samouczek dotyczący tworzenia i formatowania skoroszytów
• Eksportowanie DataSet i DataTable do Excela — oficjalny przewodnik dotyczący metody LoadWorkSheetsFromDataSet
• Import danych z Excela do SQL — kompletny proces w obie strony
• Eksport z DataTable do Excela — przewodnik poświęcony scenariuszom z jedną tabelą
• ASP.NET Eksport DataTable do Excela — wzorce eksportu aplikacji internetowych
• Najszybszy sposób na eksportowanie tabeli danych do Excela — testy wydajności

Kup licencję na wdrożenie produkcyjne lub kontynuuj odkrywanie możliwości tej biblioteki Excel w swoich projektach .NET, korzystając z bezpłatnej wersji próbnej.