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 projektu. Najszybszym sposobem jest skorzystanie z konsoli menedżera pakietów NuGet w programie Visual Studio:

Install-Package IronXL.Excel

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

dotnet add package IronXL.Excel

Po zainstalowaniu dodaj wymagane 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 eksportu danych z SQL Server do pliku Excel obejmuje trzy kroki: ustal połączenie z bazą danych, przekaż dane do DataTable i zapisz dane 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ą ram architektury dostępu do danych ADO.NET Microsoft i stanowi standardowy sposób wypełniania obiektów DataTable z relacyjnych baz danych od wersji .NET 1.0:

1. Otwórz SqlConnection z łańcuchem 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 eksportować dane SQL, należy ustanowić 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 wymagane 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 Produkty i Kategorie -- można je załadować do DataSet, a IronXL automatycznie utworzy jeden arkusz na tabelę. 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 ASP.NET Web Forms pokazuje, jak obsłużyć zdarzenie kliknięcia przycisku, zbudować skoroszyt Excel z zapytania SQL i wysłać plik do przeglądarki jako pobieranie za pomocą 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. Dla kolumn liczbowych, takich jak sumy lub liczniki, przekaż wartość double zamiast łańcucha tekstowego, aby umożliwić prawidłowe działanie wbudowanych funkcji sortowania i agregacji Excela na wyeksportowanych danych.

Możesz eksplorować pełną gamę opcji formatowania - w tym obramowania komórek, kolory tła i maski formatu liczbowego - w dokumentacji formatowania komórek 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. Załadowanie całego zestawu wyników do DataTable przed zapisaniem go do Excela działa dobrze dla większości raportów, ale dla bardzo dużych eksportów można przetwarzać wiersze w partiach lub użyć 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.
• Strumień 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 jawnych list kolumn w poleceniu SELECT, zamiast SELECT *, aby zmniejszyć ilość danych przesyłanych z SQL Server.

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 efektywna dla obiektów DataSet średniego rozmiaru, ponieważ obsługuje iterację wierszy wewnętrznie. 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 Excel do bazy danych, załaduj przesłany plik za pomocą WorkBook.Load(filePath), iteruj po wierszach arkusza i wstaw każdy wiersz, używając sparametryzowanego 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.

Dla kierunku odwrotnego, IronXL obsługuje odczyt plików CSV w C# dla scenariuszy, w których twoje źródło danych generuje dane rozdzielane 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 Office. Zaletą IronXL jest jego pierwszorzędne wsparcie dla DataSet i DataTable przez LoadWorkSheetsFromDataSet, co zmniejsza kod eksportowy do kilku linii w porównaniu do ręcznej iteracji 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 skomplikowane zależności Interop, zapewniając jednocześnie solidne wsparcie dla DataTable, DataSet i bezpośredniej integracji z bazą 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
• Export DataSet and DataTable to Excel -- official how-to guide for the LoadWorkSheetsFromDataSet method
• 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.