Eksportowanie danych z serwera SQL do programu Microsoft Excel jest częstym zadaniem dla programistów .NET tworzących systemy raportowania, narzędzia do analizy danych i aplikacje biznesowe. Ten samouczek pokazuje, jak eksportować dane SQL do Excela przy użyciu języka C# i biblioteki IronXL, biblioteki .NET do obsługi Excela, która obsługuje cały proces bez konieczności instalacji pakietu Microsoft Office.
Bezpłatna próba, aby śledzić poniższe przykłady kodu.
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:
Alternatywnie można użyć interfejsu CLI platformy .NET:
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;Imports IronXL
Imports System.Data
Imports System.Data.SqlClientIronXL 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.
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:
SqlConnection z łańcuchem połączeniaSqlDataAdapter, aby wypełnić DataTable lub DataSet.xlsx lub .xlsTo 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.
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");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
Ten kod tworzy plik Excel z poprawnie sformatowanymi nagłówkami kolumn, pochodzącymi ze struktury tabeli serwera SQL. DataTable dt przechowuje wyniki zapytania, które następnie są zapisywane w każdej komórce systematycznie przy użyciu indeksów wierszy i kolumn opartych na zerze. IronXL obsługuje zarówno formaty .xls, jak i .xlsx dla szerokiej kompatybilności z aplikacjami Microsoft Office.
Jeśli tabela SQL zawiera kolumny DateTime lub numeryczne, odpowiednio rzutuj wartości komórek przed wywołaniem SetCellValue. Bezpośrednie przekazywanie typów numerycznych zachowuje typy danych programu Excel i umożliwia sortowanie oraz obliczenia formuł w wyeksportowanych kolumnach.
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");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
LoadWorkSheetsFromDataSet odczytuje właściwość TableName każdego DataTable wewnątrz DataSet i tworzy odpowiadającą kartę arkusza. Nazwy kolumn z DataTable stają się nagłówkami w każdym arkuszu. Ta metoda jest szczególnie przydatna dla procedur składowanych, które zwracają wiele zestawów wyników, ponieważ można wypełnić DataSet za pomocą wielu wywołań SqlDataAdapter, a następnie wszystko wyeksportować jednym krokiem.
Dla aplikacji, które muszą tworzyć pliki Excel programowo z niestandardowym formatowaniem, można nadal uzyskać dostęp do poszczególnych arkuszy po wywołaniu LoadWorkSheetsFromDataSet i stosować style, szerokości kolumn lub formuły przed zapisaniem.
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();
}
}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
Metoda ToByteArray() konwertuje cały skoroszyt na tablicę bajtów w pamięci, którą następnie zapisujesz bezpośrednio do strumienia odpowiedzi HTTP. Pozwala to uniknąć zapisywania pliku tymczasowego na dysku. W przeciwieństwie do Microsoft Interop, który wymaga object misValue zastępczych i zainstalowanej licencji Office na serwerze, IronXL działa całkowicie w kodzie zarządzanym bez żadnych zewnętrznych zależności.
Dla projektów ASP.NET Core i Razor Pages, zastąp Response.BinaryWrite przez return File(fileBytes, contentType, filename) z akcji kontrolera. Wzorzec eksportu .NET Core do Excela opiera się na tym samym podejściu polegającym na przekształcaniu skoroszytu w tablicę bajtów.
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");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 UsingStylizacja 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.
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:
workBook.SaveAs(filePath) po każdej partii, zamiast przechowywać wszystko w pamięci za pomocą ToByteArray().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.
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();
}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 UsingZapytania 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.
Istnieje kilka metod eksportowania danych SQL do programu Excel w środowisku .NET. Poniższa tabela podsumowuje kluczowe kompromisy:
| Podejście | Wymagane biuro | Obsługa DataSet | Formatowanie | Bezpieczny dla serwerów |
|---|---|---|---|---|
| IronXL | Nie | Tak (wbudowane) | Pełne style, formuły | Tak |
| Microsoft Interop | Tak | Ręczna iteracja | Pełna wersja dostępna za pośrednictwem COM | Nie (serwer COM) |
| EPPlus | Nie | Ręczna iteracja | Obszerne | Tak |
| NPOI | Nie | Ręczna iteracja | Dobrze | Tak |
| Wyjście CSV | Nie | Podręcznik | Niene | Tak |
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.
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:
LoadWorkSheetsFromDataSet methodKup 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.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
