Das Exportieren von Daten aus SQL Server nach Microsoft Excel ist eine gängige Aufgabe for .NET Entwickler, die Berichtssysteme, Datenanalysetools und Geschäftsanwendungen erstellen. Dieses Tutorial zeigt Ihnen, wie Sie SQL-Daten mit C# und IronXL , einer .NET Excel-Bibliothek, die den gesamten Prozess übernimmt, nach Excel exportieren, ohne dass eine Installation von Microsoft Office erforderlich ist.
Starten Sie Ihre kostenlose Testversion und folgen Sie den Codebeispielen unten.
Bevor Sie mit dem Programmieren beginnen, müssen Sie IronXL zu Ihrem Projekt hinzufügen. Am schnellsten geht es über die NuGet Paket-Manager-Konsole in Visual Studio:
Alternativ können Sie die .NET -Befehlszeilenschnittstelle verwenden:
Nach der Installation fügen Sie die erforderlichen Namespaces am Anfang Ihrer Datei hinzu. Mit .NET 10-Anweisungen auf oberster Ebene sieht Ihre Konfiguration folgendermaßen aus:
using IronXL;
using System.Data;
using System.Data.SqlClient;Imports IronXL
Imports System.Data
Imports System.Data.SqlClientIronXL ist für .NET Standard 2.0 und höher ausgelegt und funktioniert daher ohne zusätzliche Konfiguration mit .NET 10-, .NET Framework, ASP.NET Core und Blazor -Projekten. Das Paket finden Sie auf NuGet .
Der effizienteste Ansatz zum Exportieren von Daten aus SQL Server in eine Excel-Datei umfasst drei Schritte: Stellen Sie eine Datenbankverbindung her, rufen Sie Daten in eine DataTable ab und schreiben Sie die Daten mit IronXL in ein Excel-Arbeitsblatt. Im Gegensatz zu Microsoft Interop-Lösungen arbeitet IronXL unabhängig und verarbeitet große Datensätze ohne Leistungsengpässe durch COM-Interop-Overhead.
Das Grundmuster ist einfach. SqlDataAdapter ist Teil des ADO.NET-Datenzugriffsframeworks von Microsoft und seit .NET 1.0 der Standardweg, DataTable-Objekte aus relationalen Datenbanken zu füllen:
SqlConnection mit Ihrem Verbindungsstring.SqlDataAdapter, um einen DataTable oder DataSet zu füllen..xlsx oder .xls.Dieser Ansatz ist kompatibel mit SQL Server 2012 und späteren Versionen sowie mit Azure SQL Database, Amazon RDS für SQL Server und allen ADO.NET-kompatiblen Datenquellen. Das gleiche Muster gilt unabhängig davon, ob Sie mit einer Konsolenanwendung oder einem webbasierten Berichtstool arbeiten.
Bevor Sie SQL-Daten exportieren können, müssen Sie eine Verbindung herstellen und eine SQL-Abfrage ausführen, um eine DataTable zu füllen. Die Verbindungszeichenfolge enthält die Anmeldeinformationen für die SQL-Server-Datenbank und die Serverinformationen, die für den Zugriff auf Ihre Daten erforderlich sind.
Das folgende Beispiel fragt die Tabelle "Neinrthwind Customers" ab und schreibt jede Zeile mithilfe der Cell-Writing-API von IronXL in ein Excel-Arbeitsblatt:
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=localhost;Initial Catalog=Neinrthwind;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");
Dieser Code erstellt eine Excel-Datei mit korrekt formatierten Spaltenüberschriften, die von Ihrer SQL Server-Tabellenstruktur abgeleitet sind. Die DataTable dt speichert die Abfrageergebnisse, die dann systematisch mithilfe von nullbasierten Zeilen- und Spaltenindizes in jede Zelle geschrieben werden. IronXL unterstützt sowohl .xls als auch .xlsx Formate für eine breite Kompatibilität mit Microsoft Office-Anwendungen.
Wenn Ihre SQL-Tabelle DateTime oder numerische Spalten enthält, dann konvertieren Sie die Zellwerte entsprechend, bevor Sie SetCellValue aufrufen. Durch die direkte Übergabe numerischer Datentypen bleiben die Excel-Datentypen erhalten und die Sortierung sowie Formelberechnungen in den exportierten Spalten werden ermöglicht.
Wenn Ihr Bericht Daten aus mehreren SQL-Tabellen benötigt -- zum Beispiel Produkte und Kategorien -- können Sie diese in eine DataSet laden und IronXL lässt automatisch ein Arbeitsblatt pro Tabelle erstellen. Dies ist die kürzeste Methode, um ein DataSet oder eine DataTable nach Excel zu exportieren .
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 liest die TableName-Eigenschaft jedes DataTable innerhalb der DataSet und erstellt einen entsprechenden Arbeitsblatt-Tab. Die Spaltennamen aus der DataTable werden zur Kopfzeile in jedem Blatt. Diese Methode ist besonders nützlich für gespeicherte Prozeduren, die mehrere Ergebnismengen zurückgeben, da Sie die DataSet mit mehreren SqlDataAdapter-Aufrufen füllen und dann alles in einem einzigen Schritt exportieren können.
Für Anwendungen, die programmatisch Excel-Dateien mit benutzerdefiniertem Format erstellen müssen, können Sie nach dem Aufruf von LoadWorkSheetsFromDataSet weiterhin auf einzelne Arbeitsblätter zugreifen und Stile, Spaltenbreiten oder Formeln anwenden, bevor Sie speichern.
Bei Webanwendungen wird der Export typischerweise ausgelöst, wenn ein Benutzer auf eine Schaltfläche klickt. Das folgende ASP.NET Web Forms-Beispiel zeigt, wie man das Klickereignis einer Schaltfläche behandelt, die Excel-Arbeitsmappe aus einer SQL-Abfrage erstellt und die Datei als Download mit Response.AddHeader an den Browser sendet:
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
Die ToByteArray()-Methode konvertiert die gesamte Arbeitsmappe in ein im Speicher befindliches Byte-Array, welches Sie dann direkt in den HTTP-Antwortstrom schreiben. Dadurch wird vermieden, dass eine temporäre Datei auf die Festplatte geschrieben wird. Anders als Microsoft Interop, welches object misValue Platzhalter und eine installierte Office-Lizenz auf dem Server erfordert, läuft IronXL vollständig in verwaltetem Code ohne externe Abhängigkeiten.
Für ASP.NET Core und Razor Pages-Projekte ersetzen Sie Response.BinaryWrite durch return File(fileBytes, contentType, filename) aus Ihrer Controller-Aktion. Das Exportmuster von ASP.NET Core nach Excel folgt dem gleichen Ansatz, Arbeitsmappe in Byte-Array zu konvertieren.
Rohe SQL-Exporte müssen oft präsentationstechnisch verbessert werden, bevor sie an Endbenutzer weitergegeben werden können. IronXL ermöglicht Ihnen die Kontrolle über Zellstile, Spaltenbreiten und Zahlenformate, nachdem Daten in das Arbeitsblatt geschrieben wurden. Das folgende Beispiel zeigt, wie man die Kopfzeile fett formatiert und die Spaltenbreiten automatisch anpasst:
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 UsingDurch die Formatierung der Kopfzeile mit Fettdruck und einer größeren Schriftart werden exportierte Berichte in Excel besser lesbar. Für Zahlenspalten wie Summen oder Zählungen ermöglicht die Übergabe eines double-Wertes anstelle eines Strings, dass die nativen Sortier- und Aggregationsfunktionen von Excel korrekt auf die exportierten Daten angewendet werden.
Sie können die gesamte Palette an Formatierungsoptionen – einschließlich Zellrahmen, Hintergrundfarben und Masken für Zahlenformate – in der IronXL-Zellformatierungsdokumentation erkunden.
Bei Tabellen mit Zehntausenden von Zeilen wird die Speicherverwaltung wichtig. Das Laden des gesamten Ergebnissatzes in eine DataTable, bevor Sie nach Excel schreiben, funktioniert gut für die meisten Berichte, aber für sehr große Exporte können Sie Zeilen in Stapeln verarbeiten oder SqlDataReader direkt verwenden.
Bei der Abwicklung von Exporten in großem Umfang sollten Sie folgende Strategien in Betracht ziehen:
workBook.SaveAs(filePath) nach jeder Charge auf, anstatt alles im Speicher mit ToByteArray() zu halten.SELECT-Anweisung anstelle von SELECT *, um die Menge der aus SQL Server übertragenen Daten zu reduzieren.Eine Anleitung zum schnellsten Export einer DataTable nach Excel in C# finden Sie im IronXL Blog in einem speziellen Benchmark-Artikel, in dem verschiedene Ansätze und deren Speicherprofile verglichen werden.
Die WorkBook.LoadWorkSheetsFromDataSet-Methode ist besonders effizient für mittelgroße DataSet-Objekte, da sie die Zeileniteration intern behandelt. Speziell für das Exportszenario DataTable nach Excel reduziert diese Methode den Boilerplate-Code und ist für Massenschreibvorgänge optimiert.
Der Export-Workflow ist für viele Reporting-Anwendungen nur die halbe Miete. Möglicherweise müssen Sie Benutzern auch die Möglichkeit geben, eine Vorlage herunterzuladen, Daten einzugeben und diese anschließend wieder auf den SQL Server hochzuladen. IronXL vereinfacht diesen bidirektionalen Workflow.
Um Excel-Daten in eine Datenbank zu importieren, laden Sie die hochgeladene Datei mit WorkBook.Load(filePath), iterieren Sie über die Arbeitsblattzeilen und fügen Sie jede Zeile mit einer parametrierten SqlCommand ein:
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.ExecuteNeinnQuery();
}Parametrisierte Abfragen schützen vor SQL-Injection beim Lesen von vom Benutzer bereitgestellten Excel-Daten. Die SqlCommand-Dokumentation auf Microsoft Learn behandelt alle verfügbaren Überladungen und Parameterbindungsmuster. Überprüfen Sie die Zellenwerte immer vor dem Einfügen – achten Sie auf leere Zeichenketten, Zahlen außerhalb des zulässigen Bereichs und unerwartete Datentypen, die zu Integritätsverletzungen in Ihrer SQL Server-Tabelle führen könnten.
In die andere Richtung unterstützt IronXL auch das Lesen von CSV-Dateien in C# für Szenarien, in denen Ihre Datenquelle kommagetrennte Ausgaben anstelle von .xlsx-Dateien erzeugt.
Für den Export von SQL-Daten nach Excel in .NET gibt es verschiedene Ansätze. Die folgende Tabelle fasst die wichtigsten Abwägungen zusammen:
| Ansatz | Büro erforderlich | Unterstützung für Datensätze | Formatierung | Serversicher |
|---|---|---|---|---|
| IronXL | Nein | Ja (integriert) | Vollständige Stile, Formeln | Ja |
| Microsoft Interop | Ja | Manuelle Iteration | Vollständig über COM | Nein (COM-Server) |
| EPPlus | Nein | Manuelle Iteration | Umfangreich | Ja |
| NPOI | Nein | Manuelle Iteration | Gut | Ja |
| CSV-Ausgabe | Nein | Handbuch | Neinne | Ja |
Microsoft Interop erfordert die Installation von Office auf dem Server und wird in serverseitigen Webanwendungen nicht unterstützt. IronXL, EPPlus und NPOI funktionieren alle ohne Office. Der Vorteil von IronXL ist die erstklassige DataSet- und DataTable-Unterstützung durch LoadWorkSheetsFromDataSet, die den Exportcode auf wenige Zeilen reduziert, verglichen mit der manuellen Zeileniteration in anderen Bibliotheken.
Einen detaillierten direkten Vergleich finden Sie im Artikel über Alternativen zu Microsoft Office Interop .
Der Export von SQL-Daten nach Excel unter Verwendung von C# wird mit IronXL zum Kinderspiel. Die Bibliothek beseitigt komplexe Interop-Abhängigkeiten, während sie starken Support für DataTable, DataSet und direkte Datenbankintegration bietet. Egal ob Sie Konsolenanwendungen oder webbasierte Berichtssysteme mit Dateidownload-Funktion erstellen, IronXL liefert zuverlässige Excel-Dateigenerierung für alle .NET 10-Projekttypen.
Um auf dieser Grundlage weiter aufzubauen, erkunden Sie diese verwandten Ressourcen:
LoadWorkSheetsFromDataSet-MethodeErwerben Sie eine Lizenz für den Produktiveinsatz oder erkunden Sie die volle Funktionalität dieser Excel-Bibliothek mit einer kostenlosen Testversion in Ihren .NET -Projekten.
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.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
