Ikona wiadomości
Przejdź do treści stopki
  1. Iron Software
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Eksportowanie tabeli danych przy użyciu Oledb
KORZYSTANIE Z IRONXL

Eksportuj DataTable do Excel C# przy użyciu OleDb vs IronXL

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Eksportowanie tabeli danych (DataTable) do pliku Excel w języku C# — bez żadnych zależności od pakietu Office — jest proste przy użyciu odpowiedniej biblioteki. Wywołujesz WorkBook.Create(), zapisujesz nagłówki z dataTable.Columns, przechodzisz przez pętlę dataTable.Rows, aby wypełnić komórki, a następnie zapisujesz za pomocą workbook.SaveAs("output.xlsx"). Wynikiem jest w pełni sformatowany plik XLSX, który działa na każdej platformie, w tym .NET 10, kontenerach Linux oraz funkcjach bezserwerowych Azure.

W niniejszym przewodniku porównano starsze podejście OleDb z nowoczesną metodą IronXL for .NET. Zobaczysz, dłączego sterownik OleDb powoduje problemy z wdrażaniem i kompatybilnością oraz jak zastąpić go czystym, łatwym w utrzymaniu kodem, który obsługuje nagłówki kolumn, typy danych, formatowanie komórek i duże zbiory danych bez składni SQL lub instalacji sterowników dostępnych wyłącznie dla systemu Windows.

Jak zainstalować IronXL do eksportu tabel danych?

Przed napisaniem jakiegokolwiek kodu eksportującego dodaj IronXL do swojego projektu. Otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

IronXL nie jest zależny od pakietu Microsoft Office, silnika baz danych Access ani żadnej warstwy interoperacyjności COM. Po zainstalowaniu pakietu można uruchamiać ten sam kod w systemach Windows, Linux, macOS, Docker, Azure i AWS bez zmiany ani jednej linii.

Dłączego OleDb wymaga instalacji sterownika

Tradycyjne podejście OleDb traktuje plik Excel jako bazę danych. Tworzysz OleDbConnection przy użyciu dostawcy Microsoft.ACE.OLEDB.12.0 (lub starszego Microsoft.Jet.OLEDB.4.0 dla plików .xls), a następnie wykonujesz polecenia SQL CREATE TABLE i INSERT INTO na arkuszu kalkulacyjnym. Działa to na komputerach programistów, na których zainstalowano już pakiet Microsoft Office lub samodzielny pakiet Access Database Engine. Jednak środowiska produkcyjne — zwłaszcza funkcje chmurowe, kontenery Docker i farmy serwerów z bezgłowym .NET 10 — rzadko mają ten sterownik, a jego instalacja wymaga podwyższonych uprawnień oraz zgodności bitowej między sterownikiem a procesem.

Dłączego programiści nadal używają OleDb do eksportu do Excela?

OleDb stało się domyślnym wyborem do automatyzacji programu Excel, ponieważ było już częścią .NET Framework. Programiści znali już ADO.NET, więc ponowne wykorzystanie OleDbConnection, OleDbCommand i OleDbDataAdapter do zapisywania danych w Excelu wydawało się naturalne. Nie były potrzebne żadne pakiety stron trzecich, a składnia podobna do SQL dla CREATE TABLE i INSERT INTO sprawiała, że intencja była oczywista dla każdego, kto zna się na programowaniu baz danych.

Oto tradycyjny wzorzec eksportowania tabeli danych (DataTable) przy użyciu OleDb:

using System.Data;
using System.Data.OleDb;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDb connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDbConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDbCommand(create, connection))
    createCmd.ExecuteNienQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDbCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDbParameter("ProductID", OleDbType.Integer));
insertCmd.Parameters.Add(new OleDbParameter("ProductName", OleDbType.VarChar, 255));
insertCmd.Parameters.Add(new OleDbParameter("Price", OleDbType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNienQuery();
}
using System.Data;
using System.Data.OleDb;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDb connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDbConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDbCommand(create, connection))
    createCmd.ExecuteNienQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDbCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDbParameter("ProductID", OleDbType.Integer));
insertCmd.Parameters.Add(new OleDbParameter("ProductName", OleDbType.VarChar, 255));
insertCmd.Parameters.Add(new OleDbParameter("Price", OleDbType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNienQuery();
}
Imports System.Data
Imports System.Data.OleDb

' Build a sample DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' OleDb connection string -- file must already exist on disk
Dim filename As String = "C:\Output\Products.xlsx"
Dim connectionString As String = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" &
                                 "Extended Properties='Excel 12.0 Xml;HDR=YES'"

Using connection As New OleDbConnection(connectionString)
    connection.Open()

    ' Create the sheet structure with SQL DDL
    Dim create As String = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)"
    Using createCmd As New OleDbCommand(create, connection)
        createCmd.ExecuteNonQuery()
    End Using

    ' Insert rows one at a time
    Dim insert As String = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)"
    Using insertCmd As New OleDbCommand(insert, connection)
        insertCmd.Parameters.Add(New OleDbParameter("ProductID", OleDbType.Integer))
        insertCmd.Parameters.Add(New OleDbParameter("ProductName", OleDbType.VarChar, 255))
        insertCmd.Parameters.Add(New OleDbParameter("Price", OleDbType.Double))

        For Each row As DataRow In dataTable.Rows
            insertCmd.Parameters(0).Value = row("ProductID")
            insertCmd.Parameters(1).Value = row("ProductName")
            insertCmd.Parameters(2).Value = row("Price")
            insertCmd.ExecuteNonQuery()
        Next
    End Using
End Using
$vbLabelText   $csharpLabel

Ten kod wstawia każdy DataRow jako oddzielną operację w obie strony z bazą danych. W przypadku dużych zbiorów danych pętla ta staje się wąskim gardłem, ponieważ w OleDb nie ma dostępnego mechanizmu wstawiania wsadowego. Każdy wiersz uruchamia pełny cykl analizy SQL, powiązania parametrów i zapisu przed przejściem do następnego.

Jakie są główne ograniczenia OleDb for Excel Export?

Zrozumienie, dłączego OleDb nie spełnia oczekiwań, pomoże Ci uzasadnić migrację przed zespołem i wybrać odpowiedni zamiennik.

Zależności sterowników i konflikty bitowości

Dostawca Microsoft.ACE.OLEDB.12.0 musi być zainstalowany osobno na każdym komputerze, na którym działa aplikacja. Jeśli proces jest 64-bitowy, ale dostępny jest tylko 32-bitowy silnik bazy danych Access — co jest częstą konfiguracją w przypadku, gdy 32-bitowy pakiet Microsoft Office jest zainstalowany obok 64-bitowego środowiska uruchomieniowego .NET — połączenie generuje wyjątek w czasie wykonywania. Firma Microsoft dokumentuje te ograniczenia dotyczące liczby bitów i zaleca stosowanie zgodnej liczby bitów między sterownikiem a procesem wywołującym, ale często jest to niepraktyczne w przypadku hostingu współdzielonego lub środowisk kontenerowych.

Brak obsługi wielu platform

OleDb to technologia dostępna wyłącznie w systemie Windows. .NET 10 natywnie obsługuje systemy Linux i macOS, a nowoczesne architektury coraz częściej uruchamiają obciążenia aplikacji w kontenerach Docker na węzłach Linux. Ponieważ przestrzeń nazw System.Data.OleDb generuje wyjątek PlatformNietSupportedException w systemach operacyjnych innych niż Windows, wszelkie ścieżki kodu wykorzystujące OleDb są całkowicie zablokowane na tych platformach.

Brak możliwości formatowania komórek

OleDb traktuje arkusz kalkulacyjny jako płaską tabelę bazy danych. Można wstawiać wartości surowe, ale nie ma możliwości stosowania czcionek komórek, kolorów tła, obramowań, formatów liczb ani szerokości kolumn. Jeśli eksport wymaga profesjonalnie wyglądającego raportu ze stylizacją wiersza nagłówkowego, formatowaniem waluty lub warunkówym kolorowaniem, OleDb nie jest w stanie tego zapewnić. Konieczne byłoby przeprowadzenie drugiego przejścia z wykorzystaniem innej biblioteki lub obiektu COM Excel Interop, co wiąże się z dodaniem własnej zależności od pakietu Office.

Plik Excel musi już istnieć

OleDb nie może utworzyć nowego skoroszytu programu Excel od podstaw. Plik musi już istnieć w ścieżce docelowej przed otwarciem połączenia. Wymaga to albo wstępnie przygotowanego pliku szablonu, albo osobnego kroku polegającego na utworzeniu skoroszytu przy użyciu innej biblioteki, co niepotrzebnie komplikuje pakiet wdrożeniowy.

Operacje DELETE nie są obsługiwane

Sterownik OleDb dla programu Excel obsługuje operacje INSERT i ograniczone operacje UPDATE, ale usuwanie wierszy za pomocą DELETE FROM nie jest obsługiwane. Każdy proces przetwarzania danych, który wymaga usunięcia wierszy po eksporcie, musi polegać na ręcznej manipulacji plikiem lub jego całkowitym odtworzeniu, a żadna z tych czynności nie jest prosta do wykonania za pośrednictwem interfejsu OleDb.

Jak wyeksportować tabelę danych do programu Excel za pomocą IronXL?

IronXL zastępuje cały potok OleDb bezpośrednim modelem obiektowym. Nie ma ciągów połączeń, poleceń SQL ani wymagań dotyczących sterowników. Tworzysz WorkBook, dodajesz WorkSheet i wywołujesz SetCellValue() dla każdej komórki:

using IronXL;
using System.Data;

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers into the first row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
    }
}

workbook.SaveAs("Products.xlsx");
using IronXL;
using System.Data;

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers into the first row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
    }
}

workbook.SaveAs("Products.xlsx");
Imports IronXL
Imports System.Data

' Build the same DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' Create a new workbook and worksheet -- no template file needed
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write column headers into the first row
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

' Write data rows
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

workbook.SaveAs("Products.xlsx")
$vbLabelText   $csharpLabel

WorkBook.Create(ExcelFileFormat.XLSX) tworzy nowy skoroszyt w pamięci — nie jest wymagańe wcześniejsze istnienie pliku. CreateWorkSheet("Products") dodaje zakładkę o podanej nazwie. Pętle zagnieżdżone dokładnie odzwierciedlają liczbę wierszy i kolumn w tabeli DataTable, zapisując jedną wartość w każdej komórce. SaveAs() zapisuje skoroszyt na dysku jako w pełni poprawny plik XLSX.

Wynik

Jak wyeksportować tabelę danych do programu Excel w języku C# przy użyciu OleDb lub IronXL: Obraz 1 — Wynik w programie Excel

Aby uzyskać bardziej szczegółowe informacje na temat dostępnych opcji, w poradniku dotyczącym eksportu DataSet i DataTable omówiono dodatkowe przeciążenia i wzorce eksportu zbiorczego.

Jak dodać formatowanie komórek podczas eksportowania tabeli danych?

Jednym z najczęstszych wymagań po podstawowym eksporcie jest stylizacja wiersza nagłówkowego w celu odróżnienia go od wierszy danych. IronXL udostępnia pełny interfejs API do stylizacji, z którym OleDb nie może się równać:

using IronXL;
using IronXl.Styles;
using System.Data;

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
using IronXL;
using IronXl.Styles;
using System.Data;

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
Imports IronXL
Imports IronXl.Styles
Imports System.Data

Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write and style the header row
For col As Integer = 0 To dataTable.Columns.Count - 1
    Dim headerCell = worksheet($"{ChrW(AscW("A"c) + col)}1")
    headerCell.Value = dataTable.Columns(col).ColumnName
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.FontColor = "#FFFFFF"
Next

' Write data rows with price column formatted as currency
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        Dim cell = worksheet($"{ChrW(AscW("A"c) + col)}{row + 2}")
        cell.Value = dataTable.Rows(row)(col).ToString()

        ' Apply currency format to the Price column
        If dataTable.Columns(col).ColumnName = "Price" Then
            cell.FormatString = "$#,##0.00"
        End If
    Next
Next

' Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)

workbook.SaveAs("ProductsStyled.xlsx")
$vbLabelText   $csharpLabel

Wynikiem jest plik z niebieskim wierszem nagłówka, białym tekstem nagłówka oraz wartościami cen wyświetlanymi ze znakiem dolara i dwoma miejscami po przecinku. Przewodnik po rozmiarach czcionek w komórkach oraz odniesienia dotyczące obramowań i wyrównania wyjaśniają pełen zestaw dostępnych opcji stylizacji.

Obsługa eksportu dużych tabel danych

W przypadku zbiorów danych zawierających tysiące wierszy liczy się wydajność. IronXL zapisuje wszystkie wartości komórek w pamięci przed pojedynczym zapisem na dysk w SaveAs(), co jest znacznie bardziej wydajne niż wzorzec OleDb, w którym na każdy wiersz przypada jeden ExecuteNienQuery(). Jeśli chcesz eksportować bardzo duże tabele, przewodnik "Najszybszy sposób eksportowania DataTable do Excela" opisuje techniki strumieniowania oszczędzające pamięć.

Można również grupować logikę eksportu z formułami, zakresami i nazwanymi tabelami. Poradnik tworzenia arkuszy kalkulacyjnych oraz przewodnik pisania w Excelu w .NET zawierają kompletne wzorce tworzenia skoroszytów wielarkuszowych z wykorzystaniem DataTables.

Jak wyeksportować tabelę danych do programu Excel w ASP.NET?

W aplikacji internetowej zazwyczaj przesyła się skoroszyt bezpośrednio do przeglądarki, zamiast zapisywać go na dysku. IronXL obsługuje to za pomocą workbook.ToByteArray(), które zwraca zawartość binarną, którą można zapisać w odpowiedzi HTTP:

// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
' In an ASP.NET controller action
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Assume dataTable is populated from your data source
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

Dim fileBytes As Byte() = workbook.ToByteArray()
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx")
$vbLabelText   $csharpLabel

Samouczek dotyczący eksportowania tabeli danych DataTable do programu Excel w środowisku ASP.NET przedstawia kompletną konfigurację kontrolera i widoku dla aplikacji ASP.NET. Przewodnik "DataTable to Excel C#" obejmuje dodatkowe scenariusze, w tym eksport do wielu arkuszy oraz obsługę DataSet.

Porównanie OleDb i IronXL w skrócie

Porównanie funkcji OleDb i IronXL w zakresie eksportu DataTable do Excela w języku C#
Możliwości OleDb IronXL
Wymagana instalacja sterowników Tak (ACE.OLEDB lub Jet) Nie
Wielopłatformowe (.NET 10 / Linux) Nie Tak
Utwórz nowy skoroszyt od podstaw Nie Tak
Formatowanie komórek i stylizacja Nie Tak
Obsługa formuł Nie Tak
Wydajność wstawiania zbiorczego Row-by-row (slow) W pamięci (szybkie)
Obsługa wierszy DELETE Nie Tak
Obsługa Docker / kontenerów Nie Tak

Jak radzisz sobie z typami danych kolumn podczas eksportu?

Gdy kolumna DataTable zawiera wartości liczbowe lub daty, zapisanie ich jako ciągów znaków powoduje, że program Excel traktuje komórkę jako tekst, co uniemożliwia sortowanie, filtrowanie i odwołania do formuł. IronXL zachowuje typy natywne, gdy przekazujesz wartość bezpośrednio, zamiast wywoływać .ToString():

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

// Write headers
for (int col = 0; col < table.Columns.Count; col++)
    worksheet.SetCellValue(0, col, table.Columns[col].ColumnName);

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

// Write headers
for (int col = 0; col < table.Columns.Count; col++)
    worksheet.SetCellValue(0, col, table.Columns[col].ColumnName);

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
Imports System
Imports System.Data

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("TypedData")

Dim table As New DataTable()
table.Columns.Add("ID", GetType(Integer))
table.Columns.Add("Amount", GetType(Decimal))
table.Columns.Add("Date", GetType(DateTime))
table.Rows.Add(1, 1500.75D, New DateTime(2025, 6, 15))
table.Rows.Add(2, 3200.00D, New DateTime(2025, 7, 4))

' Write headers
For col As Integer = 0 To table.Columns.Count - 1
    worksheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next

' Write typed values -- no .ToString() conversion
For row As Integer = 0 To table.Rows.Count - 1
    worksheet.SetCellValue(row + 1, 0, CInt(table.Rows(row)("ID")))
    worksheet.SetCellValue(row + 1, 1, CDbl(CDec(table.Rows(row)("Amount"))))
    worksheet($"C{row + 2}").Value = CType(table.Rows(row)("Date"), DateTime)
    worksheet($"C{row + 2}").FormatString = "yyyy-MM-dd"
Next

workbook.SaveAs("TypedData.xlsx")
$vbLabelText   $csharpLabel

Program Excel umożliwia teraz sortowanie kolumny "Kwota" według wartości liczbowych oraz filtrowanie kolumny "Data" za pomocą selektorów daty. Aby uzyskać informacje na temat dodatkowych wzorców formatów danych, zapoznaj się z przewodnikiem dotyczącym formatów danych komórek. Jeśli chcesz odczytać dane po eksporcie, samouczek "Excel do DataTable" opisuje tę operację w odwrotnej kolejności.

Migracja istniejącego kodu eksportu OleDb

Migracja z OleDb do IronXL zajmuje zazwyczaj mniej czasu niż jeden sprint. Zmiany strukturalne są następujące:

  1. Usuń wszystkie odniesienia using System.Data.OleDb oraz odniesienia NuGet do jakiegokolwiek pakietu opakowującego sterownik ACE.
  2. Zastąp blok inicjalizacyjny OleDbConnection blokiem WorkBook.Create(ExcelFileFormat.XLSX).
  3. Zastąp polecenie CREATE TABLE poleceniem workbook.CreateWorkSheet("SheetName").
  4. Zastąp pętlę INSERT INTO zagnieżdżonymi wywołaniami SetCellValue(), po jednym na komórkę.
  5. Zastąp connection.Close() przez workbook.SaveAs("output.xlsx").

Można również wywołać workbook.SaveAs() z rozszerzeniem .xls, aby wygenerować pliki w starszym formacie, jeśli odbiorcy końcowi nie zaktualizowali jeszcze oprogramowania do wersji Excel 2007 lub nowszej. W przewodniku dotyczącym typów plików arkuszy kalkulacyjnych wymieniono wszystkie obsługiwane formaty wyjściowe.

Jak przetestować i uzyskać licencję na IronXL?

IronXL jest dostępny do użytku w celach programistycznych na Licencji Trial. Klucz należy zastosować w kodzie przed pierwszym wywołaniem IronXL:

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
Imports IronXl

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

Podręcznik dotyczący klucza licencyjnego omawia wszystkie opcje umieszczenia, w tym pliki konfiguracyjne i zmienne środowiskowe. W przypadku wdrożeń w chmurze strony z instrukcjami dla Docker i Linux zawierają kroki konfiguracji specyficzne dla danej platformy.

Firma Microsoft dokumentuje znane ograniczenia silnika baz danych Access w scenariuszach OleDb, a serwis NuGet.org udostępnia pakiet IronXL wraz z pełną historią wersji i statystykami pobrań. Oficjalna dokumentacja Open XML SDK wyjaśnia podstawową specyfikację XLSX, którą implementuje IronXL.

Jakie są Twoje kolejne kroki?

Masz teraz gotowy wzorzec eksportowania tabeli DataTable do pliku XLSX bez sterowników OleDb, bez składni SQL i bez ograniczeń platformowych. Podstawowy przebieg pracy — WorkBook.Create(), CreateWorkSheet(), SetCellValue() w pętli, a następnie SaveAs() — skaluje się od trzywierszowej próbki do zbiorów danych zawierających setki tysięcy wierszy.

Zacznij od zastąpienia istniejącego eksportu OleDb podstawowym wzorcem IronXL pokazanym powyżej, a następnie, po zweryfikowaniu eksportu danych, dodaj formatowanie za pomocą API stylizacji. Przewodnik dla początkujących dotyczący IronXL oraz przegląd funkcji to kolejne pozycje, które warto przeczytać, aby w pełni zrozumieć zakres możliwości biblioteki IronXL. Jeśli pracujesz z plikami CSV w ramach tego samego procesu, przewodnik C# DataTable to CSV pokazuje, jak wygenerować dane rozdzielone przecinkami z tego samego obiektu DataTable.

Często Zadawane Pytania

Jakie są ograniczenia korzystania z OleDb do eksportowania DataTable do Excela w C#?

Korzystanie z OleDb do eksportowania DataTable do Excela w C# może być frustrujące ze względu na jego przestarzały charakter. Programiści często napotykają ograniczenia, takie jak problemy z kompatybilnością, wolniejsze działanie i bardziej skomplikowane obsługiwanie błędów, co sprawia, że nowoczesne alternatywy, takie jak IronXL, są bardziej atrakcyjne.

W jaki sposób IronXL usprawnia proces eksportowania tabeli DataTable do programu Excel?

IronXL oferuje nowoczesne podejście do eksportowania tabel danych (DataTable) do programu Excel, zapewniając lepszą wydajność, szerszą kompatybilność i uproszczony kod. Eliminuje typowe frustracje związane z OleDb, ułatwiając programistom .NET zarządzanie eksportami do programu Excel.

Dlaczego warto rozważyć przejście z OleDb na IronXL w przypadku eksportu tabel danych?

Przejście na IronXL do eksportu tabel danych oferuje kilka korzyści, w tym lepszą wydajność, łatwiejszą implementację i zwiększoną kompatybilność z nowoczesnymi aplikacjami .NET, co zmniejsza czas i wysiłek potrzebny do rozwoju.

Czy IronXL radzi sobie z eksportem dużych tabel danych (DataTable) bardziej efektywnie niż OleDb?

Tak, IronXL został zaprojektowany do wydajnej obsługi eksportu dużych tabel danych (DataTable), oferując szybsze przetwarzanie i mniejsze zużycie pamięci w porównaniu z OleDb, co czyni go idealnym rozwiązaniem dla aplikacji obsługujących duże zbiory danych.

Czy IronXL jest kompatybilny z najnowszymi wersjami C# i .NET?

IronXL jest w pełni kompatybilny z najnowszymi wersjami C# i .NET, co zapewnia płynną integrację z nowoczesnymi aplikacjami, a jednocześnie zapewnia ciągłe aktualizacje w celu obsługi nowych funkcji i ulepszeń.

Jakie korzyści oferują nowoczesne alternatywy, takie jak IronXL, w porównaniu z tradycyjnym OleDb?

Nowoczesne alternatywy, takie jak IronXL, zapewniają korzyści, takie jak lepsza wydajność, łatwiejsze obsługiwanie błędów, lepsza kompatybilność z różnymi formatami Excel oraz uproszczony kod, co może znacznie zwiększyć produktywność programistów.

W jaki sposób IronXL radzi sobie z zarządzaniem błędami w porównaniu z OleDb?

IronXL oferuje uproszczone zarządzanie błędami z przejrzystą obsługą wyjątków, zmniejszając złożoność i potencjalne problemy związane z OleDb, co ułatwia programistom debugowanie i utrzymanie ich aplikacji.

Jakie są typowe przypadki użycia eksportowania DataTable do Excela w aplikacjach .NET opartych na interfejsie użytkownika?

W aplikacjach .NET opartych na interfejsie użytkownika eksportowanie tabeli danych (DataTable) do programu Excel jest powszechnie stosowane do generowania raportów, analizy danych i przyjaznej dla użytkownika manipulacji danymi, często uruchamianej z poziomu procedur obsługi zdarzeń przy użyciu wzorców obiektowych nadawców.

Jordi Bardia
Jordi Bardia
  Czat z zespołem inżynierów teraz
Inżynier oprogramowania
Jordi jest najbardziej biegły w Pythonie, C# i C++. Kiedy nie wykorzystuje swoich umiejętności w Iron Software, programuje gry. Dzieląc odpowiedzialność za testowanie produktów, rozwój produktów i badania, Jordi wnosi ogromną wartość do ciągłej poprawy produktów. Różnorodne doświadczenia ...
Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie