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

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

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

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: 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:

1. Öffnen Sie eine SqlConnection mit Ihrem Verbindungsstring.
2. Verwenden Sie SqlDataAdapter, um einen DataTable oder DataSet zu fü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 als .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 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");

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

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

Dim connectionString As String = "Data Source=localhost;Initial Catalog=Neinrthwind;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 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");

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

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

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 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:

• 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 auf Festplatte: Rufen Sie workBook.SaveAs(filePath) nach jeder Charge auf, anstatt alles im Speicher mit ToByteArray() zu halten.
• Ausgewählte Spalten begrenzen: Verwenden Sie explizite Spaltenlisten in Ihrer 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.

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

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

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.

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.

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

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, 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:

• Excel-Datei in C# erstellen – vollständiges Tutorial zur Erstellung und Formatierung von Arbeitsmappen
• Export von DataSet und DataTable nach Excel -- Offizieller Leitfaden zur 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.