SQL-Daten mit IronXL in C# nach Excel exportieren

Wie installiert man IronXL für den SQL-Datenexport?

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:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Alternativ können Sie die .NET -Befehlszeilenschnittstelle verwenden:

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

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;

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

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

IronXL ist for .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 .

Wie exportiert man am besten Daten aus einer SQL-Server-Datenbank?

Der effizienteste Ansatz zum Exportieren von Daten aus SQL Server in eine Excel-Datei umfasst drei Schritte: Herstellen einer Datenbankverbindung, Abrufen der Daten in eine DataTable und Schreiben der Daten in ein Excel-Arbeitsblatt mit IronXL. 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 ist seit .NET 1.0 die Standardmethode zum Füllen von DataTable-Objekten aus relationalen Datenbanken:

1. Öffnen Sie eine SqlConnection-Verbindung mit Ihrer Verbindungszeichenfolge.
2. Verwenden Sie SqlDataAdapter, um ein DataTable oder DataSet auszufüllen.
3. Rufen Sie IronXL -Methoden auf, um eine Arbeitsmappe zu erstellen und die Zellen des Arbeitsblatts zu füllen.
4. Speichern Sie die Arbeitsmappe unter dem Namen .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.

Wie stellt man eine Verbindung zu SQL Server her und ruft Daten ab?

Bevor Sie SQL-Daten exportieren können, müssen Sie eine Verbindung herstellen und eine SQL-Abfrage ausführen, um ein 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 "Northwind 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=Northwind;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=Northwind;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=Northwind;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

Wie exportiert man mit LoadWorkSheetsFromDataSet mehrere Tabellen?

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 automatisch ein Arbeitsblatt pro Tabelle erstellen lassen. 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");

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

Wie können Sie Daten mit einer ASP.NET-Exportschaltfläche exportieren?

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 mithilfe von Response.AddHeader als Download 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();
    }
}

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

Wie fügt man exportierten Excel-Dateien Formatierungen und Spaltenüberschriften hinzu?

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

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

Durch die Formatierung der Kopfzeile mit Fettdruck und einer größeren Schriftart werden exportierte Berichte in Excel besser lesbar. Bei Zahlenspalten wie Summen oder Anzahlen ermöglicht die Übergabe eines double-Werts anstelle einer Zeichenkette, dass die nativen Sortier- und Aggregationsfunktionen von Excel korrekt mit den exportierten Daten arbeiten.

Die vollständige Palette der Formatierungsoptionen – einschließlich Zellrahmen, Hintergrundfarben und Zahlenformatmasken – können Sie in der IronXL Dokumentation zur Zellformatierung erkunden.

Wie verarbeitet man große SQL-Datensätze effizient?

Bei Tabellen mit Zehntausenden von Zeilen wird die Speicherverwaltung wichtig. Das Laden des gesamten Ergebnissatzes in ein DataTable vor dem Schreiben nach Excel funktioniert für die meisten Berichte gut, aber für sehr große Exporte können Sie die Zeilen in Stapeln verarbeiten oder SqlDataReader direkt verwenden.

Bei der Abwicklung von Exporten in großem Umfang sollten Sie folgende Strategien in Betracht ziehen:

• Paginierung mit SQL OFFSET/FETCH : Große Exporte in mehrere Arbeitsblätter aufteilen, von denen jedes eine Seite mit Ergebnissen enthält. Dadurch bleiben die einzelnen Tabellenblattgrößen in Excel überschaubar.
• Stream to disk : Call workBook.SaveAs(filePath) after each batch instead of hold everything in memory with ToByteArray().
• Auswahl von Spalten einschränken : Verwenden Sie in Ihrer SELECT-Anweisung explizite Spaltenlisten anstelle von SELECT *, um die Menge der vom 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 Methode WorkBook.LoadWorkSheetsFromDataSet ist besonders effizient für mittelgroße DataSet Objekte, da sie die Zeileniteration intern durchführt. Speziell für das Exportszenario DataTable nach Excel reduziert diese Methode den Boilerplate-Code und ist für Massenschreibvorgänge optimiert.

Wie importiert man Daten aus Excel zurück in SQL Server?

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), durchlaufen Sie die Zeilen des Arbeitsblatts und fügen Sie jede Zeile mit einem parametrisierten 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.ExecuteNonQuery();
}

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.ExecuteNonQuery();
}

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

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.

Für die umgekehrte 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.

Wie vergleichen Sie IronXL mit anderen Exportansätzen?

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:

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 liegt in der erstklassigen Unterstützung von DataSet und DataTable durch LoadWorkSheetsFromDataSet, wodurch der Exportcode im Vergleich zur manuellen Zeileniteration in anderen Bibliotheken auf wenige Zeilen reduziert wird.

Einen detaillierten direkten Vergleich finden Sie im Artikel über Alternativen zu Microsoft Office Interop .

Was sind Ihre nächsten Schritte?

Der Export von SQL-Daten nach Excel unter Verwendung von C# wird mit IronXL zum Kinderspiel. Die Bibliothek beseitigt komplexe Interop-Abhängigkeiten und bietet gleichzeitig starke Unterstützung für DataTable, DataSet sowie die direkte Datenbankintegration. 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:

• Excel-Datei in C# erstellen – vollständiges Tutorial zur Erstellung und Formatierung von Arbeitsmappen
• DataSet und DataTable nach Excel exportieren – offizielle Anleitung für die LoadWorkSheetsFromDataSet Methode
• Datenimport von Excel nach SQL – vollständiger Round-Trip-Workflow
• DataTable-zu-Excel-Export – Fokus auf Szenarien mit einer einzelnen Tabelle
• ASP.NET Datentabelle nach Excel exportieren – Exportmuster für Webanwendungen
• Schnellster Weg zum Exportieren von DataTables nach Excel -- Leistungsvergleich

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