Przejdź do treści stopki
KORZYSTANIE Z IRONXL

Eksportuj Excel DataTable w C# | Konwersja danych Excel

Eksportowanie danych z Excela do DataTable zapewnia strukturalny, pamięciowy dostęp do zawartości arkusza, która naturalnie współdziała z bazami danych, kontrolkami interfejsu użytkownika i zapytaniami LINQ. Odwrócony kierunek -- zapis DataTable z powrotem do pliku Excel -- jest równie ważny dla generowania raportów i przepływów danych. IronXL obsługuje oba kierunki w czystym środowisku .NET, bez zależności od pakietu Microsoft Office i bez konieczności konfiguracji interoperacyjności COM.

Zainstaluj IronXL przed uruchomieniem któregokolwiek z poniższych przykładów:

Install-Package IronXL.Excel

Po zainstalowaniu typy WorkBook i WorkSheet udostępniają metody ToDataTable i ToDataSet, które odwzorowują bezpośrednio na struktury System.Data. Można również odwrócić proces, zapisując wartości DataRow z powrotem do arkusza i zapisać plik w formacie XLSX lub XLS.

Jak przekonwertować cały arkusz na tabelę danych?

Metoda ToDataTable konwertuje cały arkusz -- lub nazwany zakres -- na System.Data.DataTable. Przekaż true, aby traktować pierwszy wiersz jako nagłówki kolumn, tak aby nazwy kolumn wynikowej tabeli dokładnie odpowiadały nagłówkom arkusza.

using IronXL;
using System.Data;

// Load the workbook from disk
WorkBook workbook = WorkBook.Load("customers.xlsx");

// Grab the default (first) worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert the entire sheet; first row becomes column headers
DataTable dataTable = worksheet.ToDataTable(true);

// Iterate every row and print each cell value
foreach (DataRow row in dataTable.Rows)
{
    for (int i = 0; i < dataTable.Columns.Count; i++)
    {
        Console.Write(row[i] + "\t");
    }
    Console.WriteLine();
}
using IronXL;
using System.Data;

// Load the workbook from disk
WorkBook workbook = WorkBook.Load("customers.xlsx");

// Grab the default (first) worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert the entire sheet; first row becomes column headers
DataTable dataTable = worksheet.ToDataTable(true);

// Iterate every row and print each cell value
foreach (DataRow row in dataTable.Rows)
{
    for (int i = 0; i < dataTable.Columns.Count; i++)
    {
        Console.Write(row[i] + "\t");
    }
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

' Load the workbook from disk
Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")

' Grab the default (first) worksheet
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Convert the entire sheet; first row becomes column headers
Dim dataTable As DataTable = worksheet.ToDataTable(True)

' Iterate every row and print each cell value
For Each row As DataRow In dataTable.Rows
    For i As Integer = 0 To dataTable.Columns.Count - 1
        Console.Write(row(i) & vbTab)
    Next
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Co robi ten kod

WorkBook.Load czyta plik XLSX bez żadnej automatyzacji Office. worksheet.ToDataTable(true) iteruje przez każdą komórkę w arkuszu i mapuje ją na DataRow, używając pierwszego wiersza jako nazw DataColumn. Wynikowy DataTable to standardowy obiekt System.Data -- można go związać z DataGridView, przekazać do SqlBulkCopy lub uruchomić zapytania LINQ bezpośrednio.

Wywołanie ToDataTable obsługuje zarówno formaty XLS, jak i XLSX, więc ten sam kod działa dla starszych arkuszy bez modyfikacji. Pełny opis API znajduje się w dokumentacji IronXL DataTable i DataSet.

Jak wyeksportować określony zakres komórek do tabeli danych?

Gdy arkusz zawiera wiele obszarów danych lub gdy potrzebny jest tylko podzbiór wierszy i kolumn, można wyeksportować określony zakres komórek zamiast całego arkusza. Takie podejście jest bardziej wydajne w przypadku dużych plików, ponieważ IronXL przetwarza tylko wybrane komórki.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access a named worksheet
WorkSheet worksheet = workbook.GetWorkSheet("Summary");

// Select only the region A1:D20 and convert it
DataTable dt = worksheet["A1:D20"].ToDataTable(true);

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}");

foreach (DataRow row in dt.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write(item + "\t");
    }
    Console.WriteLine();
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access a named worksheet
WorkSheet worksheet = workbook.GetWorkSheet("Summary");

// Select only the region A1:D20 and convert it
DataTable dt = worksheet["A1:D20"].ToDataTable(true);

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}");

foreach (DataRow row in dt.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write(item + "\t");
    }
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")

' Access a named worksheet
Dim worksheet As WorkSheet = workbook.GetWorkSheet("Summary")

' Select only the region A1:D20 and convert it
Dim dt As DataTable = worksheet("A1:D20").ToDataTable(True)

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}")

For Each row As DataRow In dt.Rows
    For Each item In row.ItemArray
        Console.Write(item & vbTab)
    Next
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Dlaczego wybór zakresu ma znaczenie

Składnia klamrowa worksheet["A1:D20"] zwraca obiekt IronXL.Range. Wywołanie ToDataTable dla tego zakresu ogranicza przetwarzanie tylko do tych komórek, co oznacza szybsze wykonanie i mniejszą pamięć, gdy plik źródłowy ma dziesiątki tysięcy wierszy.

Można również określić nazwane zakresy lub dynamicznie budować ciąg zakresu w czasie rzeczywistym -- na przykład $"A1:D{lastRow}" -- co czyni podejście elastycznym dla eksportu danych o zmiennej długości. Dokumentacja API klasy Range zawiera wszystkie dostępne metody wyboru i zapytań.

Jak przekonwertować skoroszyt wielarkuszowy na zestaw danych?

Arkusze z wieloma arkuszami mapują się naturalnie na System.Data.DataSet, gdzie każdy arkusz staje się oddzielnym DataTable. Metoda ToDataSet wykonuje tę konwersję w jednym wywołaniu.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");

// Each worksheet becomes a DataTable inside the DataSet
DataSet dataSet = workbook.ToDataSet();

foreach (DataTable table in dataSet.Tables)
{
    Console.WriteLine($"Sheet: {table.TableName}");
    Console.WriteLine($"Rows:  {table.Rows.Count}");
    Console.WriteLine();
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");

// Each worksheet becomes a DataTable inside the DataSet
DataSet dataSet = workbook.ToDataSet();

foreach (DataTable table in dataSet.Tables)
{
    Console.WriteLine($"Sheet: {table.TableName}");
    Console.WriteLine($"Rows:  {table.Rows.Count}");
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("multi_sheet.xlsx")

' Each worksheet becomes a DataTable inside the DataSet
Dim dataSet As DataSet = workbook.ToDataSet()

For Each table As DataTable In dataSet.Tables
    Console.WriteLine($"Sheet: {table.TableName}")
    Console.WriteLine($"Rows:  {table.Rows.Count}")
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Dostęp do arkuszy według nazwy

Każdy DataTable w zwróconym DataSet używa oryginalnej nazwy arkusza jako swojej właściwości TableName, więc można odnaleźć konkretny arkusz przez dataSet.Tables["Summary"] zamiast iterować przez kolekcję. Ułatwia to tworzenie logiki raportowania obejmującej wiele arkuszy lub łączenie danych z kilku arkuszy przed zapisaniem wyników w bazie danych.

Aby dowiedzieć się więcej o pracy z wieloma arkuszami i poruszaniu się po strukturze skoroszytu, zobacz, jak otwierać arkusze programu Excel i zarządzać nimi.

Jak wyeksportować tabelę danych z powrotem do pliku Excel?

Kierunek importu do DataTable to tylko połowa sukcesu. Kiedy potrzebujesz zapisać strukturalne dane jako arkusz -- dla raportów, pobrań lub archiwizacji -- tworzysz nowy skoroszyt, wypełniasz komórki z DataTable i zapisujesz.

using IronXL;
using System.Data;

// Build a sample DataTable
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("ProductID", typeof(int)));
dt.Columns.Add(new DataColumn("ProductName", typeof(string)));
dt.Columns.Add(new DataColumn("UnitPrice", typeof(decimal)));
dt.Rows.Add(1, "Widget Pro", 29.99m);
dt.Rows.Add(2, "Gadget Max", 49.99m);
dt.Rows.Add(3, "Sensor Kit", 14.50m);

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create();
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers from DataTable.Columns
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]);
    }
}

// Save as XLSX
workbook.SaveAs("products_export.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;

// Build a sample DataTable
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("ProductID", typeof(int)));
dt.Columns.Add(new DataColumn("ProductName", typeof(string)));
dt.Columns.Add(new DataColumn("UnitPrice", typeof(decimal)));
dt.Rows.Add(1, "Widget Pro", 29.99m);
dt.Rows.Add(2, "Gadget Max", 49.99m);
dt.Rows.Add(3, "Sensor Kit", 14.50m);

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create();
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers from DataTable.Columns
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]);
    }
}

// Save as XLSX
workbook.SaveAs("products_export.xlsx");
Console.WriteLine("Export complete.");
Imports IronXL
Imports System.Data

' Build a sample DataTable
Dim dt As New DataTable()
dt.Columns.Add(New DataColumn("ProductID", GetType(Integer)))
dt.Columns.Add(New DataColumn("ProductName", GetType(String)))
dt.Columns.Add(New DataColumn("UnitPrice", GetType(Decimal)))
dt.Rows.Add(1, "Widget Pro", 29.99D)
dt.Rows.Add(2, "Gadget Max", 49.99D)
dt.Rows.Add(3, "Sensor Kit", 14.50D)

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write column headers from DataTable.Columns
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))
    Next
Next

' Save as XLSX
workbook.SaveAs("products_export.xlsx")
Console.WriteLine("Export complete.")
$vbLabelText   $csharpLabel

Jak działa pętla zapisywania komórek

SetCellValue(rowIndex, columnIndex, value) akceptuje wartości object, więc przekazujesz nazwy kolumn dla wiersza nagłówka i surowe wartości komórek dla wierszy danych bez żadnej konwersji typu. Offset wiersza row + 1 rezerwuje wiersz 0 na nagłówki. Powstały plik XLSX jest w pełni poprawnym arkuszem kalkulacyjnym — bez symboli zastępczych i plików tymczasowych.

W przypadku większych tabel danych warto rozważyć zastosowanie automatycznego dostosowywania rozmiaru kolumn po zapisaniu danych, aby treść wyświetlała się przejrzyście bez konieczności ręcznego formatowania.

Jak powiązać DataTable z DataGridView?

Jednym z najczęstszych powodów eksportu arkusza Excela do DataTable jest wyświetlenie go w DataGridView Windows Forms. Gdy masz DataTable, powiązanie to jedna linia kodu.

using IronXL;
using System.Data;
using System.Windows.Forms;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
DataTable dataTable = worksheet.ToDataTable(true);

// Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable;
using IronXL;
using System.Data;
using System.Windows.Forms;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
DataTable dataTable = worksheet.ToDataTable(true);

// Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable;
Imports IronXL
Imports System.Data
Imports System.Windows.Forms

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
Dim dataTable As DataTable = worksheet.ToDataTable(True)

' Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable
$vbLabelText   $csharpLabel

Co dzieje się w momencie wiązania

Ustawienie DataSource wywołuje DataGridView, aby odczytać nazwy kolumn i dane z wierszy z DataTable. Każdy DataColumn staje się kolumną siatki, a każdy DataRow staje się widocznym wierszem. Możesz stosować sortowanie, filtrowanie i wybieranie za pomocą wbudowanych elementów sterujących siatki bez konieczności pisania dodatkowego kodu.

Wzorzec ten działa równie dobrze z DataGrid WPF, ASP.NET GridView i każdą inną infrastrukturą powiązań danych .NET. Aby uzyskać przewodnik krok po kroku, zobacz, jak wyeksportować DataGridView do Excela w odwrotnym kierunku.

Jak korzystać z zapytań LINQ w wyeksportowanej tabeli danych?

Po skonwertowaniu arkusza do DataTable można uruchomić zapytania LINQ, korzystając z metody rozszerzenia AsEnumerable(), która przekształca każdy DataRow w element zapytaniowy.

using IronXL;
using System.Data;
using System.Linq;

WorkBook workbook = WorkBook.Load("sales.xlsx");
DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);

// Filter rows where the "Revenue" column exceeds 10000
var highRevenue = dt.AsEnumerable()
    .Where(row => row.Field<double>("Revenue") > 10000)
    .OrderByDescending(row => row.Field<double>("Revenue"))
    .ToList();

Console.WriteLine($"High-revenue records: {highRevenue.Count}");
foreach (var row in highRevenue)
{
    Console.WriteLine($"{row["Product"]}: {row["Revenue"]:C}");
}
using IronXL;
using System.Data;
using System.Linq;

WorkBook workbook = WorkBook.Load("sales.xlsx");
DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);

// Filter rows where the "Revenue" column exceeds 10000
var highRevenue = dt.AsEnumerable()
    .Where(row => row.Field<double>("Revenue") > 10000)
    .OrderByDescending(row => row.Field<double>("Revenue"))
    .ToList();

Console.WriteLine($"High-revenue records: {highRevenue.Count}");
foreach (var row in highRevenue)
{
    Console.WriteLine($"{row["Product"]}: {row["Revenue"]:C}");
}
Imports IronXL
Imports System.Data
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("sales.xlsx")
Dim dt As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)

' Filter rows where the "Revenue" column exceeds 10000
Dim highRevenue = dt.AsEnumerable() _
    .Where(Function(row) row.Field(Of Double)("Revenue") > 10000) _
    .OrderByDescending(Function(row) row.Field(Of Double)("Revenue")) _
    .ToList()

Console.WriteLine($"High-revenue records: {highRevenue.Count}")
For Each row In highRevenue
    Console.WriteLine($"{row("Product")}: {row("Revenue"):C}")
Next
$vbLabelText   $csharpLabel

Dlaczego LINQ w DataTable jest przydatne

Zapytania LINQ zapewniają czytelny, silnie typowany sposób filtrowania, sortowania, grupowania i wyświetlania danych z przekonwertowanego arkusza. row.Field<t>(columnName) obsługuje wymuszanie typu w czystości, rzucając InvalidCastException, jeśli nie można przekonwertować wartości, zamiast zwracać ciche zero. Ułatwia to wczesne wykrywanie problemów z jakością danych.

Połącz to podejście z eksportem opartym na zakresach, o którym mowa w poprzedniej sekcji, aby wyszukiwać konkretne obszary arkusza zamiast całych arkuszy, co pozwala ograniczyć zużycie pamięci w przypadku dużych plików.

Jak radzisz sobie z komórkami o wartości null i pustymi komórkami podczas eksportu?

Arkusze kalkulacyjne Excel często zawierają luki — puste komórki, scalone obszary lub tekst zastępczy. IronXL mapuje puste komórki na DBNull.Value w wyeksportowanym DataTable, odwzorowując standardowe zachowanie ADO.NET, więc obecny kod obsługujący wartości null działa bez modyfikacji.

W jaki sposób IronXL mapuje stany komórek Excela na wartości DataTable
Stan komórki w Excelu Wartość DataTable Uwagi
Wartość tekstu Ciąg znaków Zwrócono bez zmian
Wartość liczbowa Podwójna lub dziesiętna Zależy od formatu komórki
Wartość daty Data i godzina Przetworzone z numeru seryjnego
Wartość logiczna Boolean PRAWDA/FAŁSZ w Excelu
Pusta komórka DBNull.Value Standardowa wartość null w ADO.NET
Komórka formuły Wynik obliczeń IronXL najpierw ocenia formułę

Podczas zapisywania DataTable z powrotem do Excela pola DBNull.Value oraz uznają się na puste komórki, zachowując wierność całego obiegu. Jeśli potrzebujesz domyślnego ciągu znaków dla pól null, zamień DBNull.Value na swoje zastępcze przed wywołaniem SetCellValue.

Więcej wskazówek dotyczących przygotowywania danych można znaleźć w dokumentacji klasy DataTable firmy Microsoft, która szczegółowo omawia obsługę wartości null, zarządzanie ograniczeniami oraz stany wierszy.

Jak oszczędzać pamięć podczas eksportowania dużych arkuszy?

W przypadku arkuszy zawierających wiele tysięcy wierszy eksportowanie całego arkusza naraz powoduje jednoczesne przydzielenie wszystkich danych w pamięci. Dwa wzorce IronXL zmniejszają szczytowe zużycie pamięci:

  • Eksport zakresu: użyj worksheet["A1:D5000"].ToDataTable(true), aby przetworzyć ograniczony obszar zamiast całego arkusza.
  • Przetwarzanie wsadowe: oblicz ostatni używany wiersz za pomocą worksheet.RowCount, następnie przetwarzaj w pętlach zakresy o stałej wielkości -- na przykład po 1 000 wierszy -- i przetwarzaj każdą partię przed przejściem do następnej.

Właściwości worksheet.RowCount i worksheet.ColumnCount umożliwiają budowanie dynamicznych ciągów zakresu bez twardego kodowania wymiarów:

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("large_dataset.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    string rangeAddress = $"A{startRow}:Z{endRow}";

    DataTable batch = worksheet[rangeAddress].ToDataTable(false);
    // Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("large_dataset.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    string rangeAddress = $"A{startRow}:Z{endRow}";

    DataTable batch = worksheet[rangeAddress].ToDataTable(false);
    // Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("large_dataset.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

Dim batchSize As Integer = 1000
Dim totalRows As Integer = worksheet.RowCount

For startRow As Integer = 1 To totalRows Step batchSize
    Dim endRow As Integer = Math.Min(startRow + batchSize - 1, totalRows)
    Dim rangeAddress As String = $"A{startRow}:Z{endRow}"

    Dim batch As DataTable = worksheet(rangeAddress).ToDataTable(False)
    ' Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}")
Next
$vbLabelText   $csharpLabel

Ten wzorzec ma szczególne znaczenie przy odczytywaniu dużych plików Excel w języku C#, gdzie występują ograniczenia pamięci.

Jak zapisać tabelę danych do bazy danych?

Gdy masz DataTable, wstawienie go do SQL Server za pomocą SqlBulkCopy to najszybsza ścieżka dla dużych zestawów danych. SqlBulkCopy akceptuje bezpośrednio DataTable i strumienie wierszy w partiach bez budowania indywidualnych instrukcji INSERT.

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

WorkBook workbook = WorkBook.Load("orders.xlsx");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

string connectionString = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

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

using SqlBulkCopy bulkCopy = new(connection);
bulkCopy.DestinationTableName = "dbo.Orders";
bulkCopy.BatchSize = 500;
bulkCopy.BulkCopyTimeout = 60;

// Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID");
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName");
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount");

bulkCopy.WriteToServer(dataTable);
Console.WriteLine("Bulk insert complete.");
using IronXL;
using System.Data;
using Microsoft.Data.SqlClient;

WorkBook workbook = WorkBook.Load("orders.xlsx");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

string connectionString = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

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

using SqlBulkCopy bulkCopy = new(connection);
bulkCopy.DestinationTableName = "dbo.Orders";
bulkCopy.BatchSize = 500;
bulkCopy.BulkCopyTimeout = 60;

// Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID");
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName");
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount");

bulkCopy.WriteToServer(dataTable);
Console.WriteLine("Bulk insert complete.");
Imports IronXL
Imports System.Data
Imports Microsoft.Data.SqlClient

Dim workbook As WorkBook = WorkBook.Load("orders.xlsx")
Dim dataTable As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)

Dim connectionString As String = "Server=.;Database=OrdersDB;Trusted_Connection=True;"

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

    Using bulkCopy As New SqlBulkCopy(connection)
        bulkCopy.DestinationTableName = "dbo.Orders"
        bulkCopy.BatchSize = 500
        bulkCopy.BulkCopyTimeout = 60

        ' Map DataTable columns to database columns
        bulkCopy.ColumnMappings.Add("OrderID", "OrderID")
        bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName")
        bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount")

        bulkCopy.WriteToServer(dataTable)
    End Using
End Using

Console.WriteLine("Bulk insert complete.")
$vbLabelText   $csharpLabel

Uwagi dotyczące mapowania kolumn

Kolekcja ColumnMappings odwzorowuje nazwy kolumn DataTable na nazwy kolumn w bazie danych. Jeśli obie nazwy są identyczne, możesz pominąć indywidualne mapowanie, a SqlBulkCopy automatycznie dopasuje je po nazwie. Jawnym mapowaniom można zaufać bardziej, gdy kolejność kolumn w arkuszu kalkulacyjnym różni się od schematu bazy danych.

Więcej informacji na temat łączenia IronXL z procesami pracy z bazami danych można znaleźć w przewodniku po importowaniu do programu Excel w języku C#, który obejmuje dodatkowe scenariusze importu, w tym walidację przed wstawieniem.

Dla projektów opartych na Entity Framework, najpierw przekonwertuj wiersze DataTable na typowe obiekty modelowe, a następnie użyj DbContext.BulkInsert z biblioteki takiej jak EFCore.BulkExtensions dla wsadowych wstawek ORM. Dokumentacja Microsoftu dotycząca SqlBulkCopy szczegółowo wyjaśnia opcje przetwarzania wsadowego i obsługę transakcji.

Jakie są Twoje kolejne kroki?

Teraz posiadasz kompletny zestaw narzędzi do przenoszenia danych między Excelem a DataTable w obu kierunkach przy użyciu IronXL:

  • Konwertuj pełny arkusz z worksheet.ToDataTable(true) dla eksportów świadomych nagłówka
  • Eksportuj określony zakres komórek z worksheet["A1:D20"].ToDataTable(true) składnią
  • Konwertuj skoroszyty z wieloma arkuszami przy użyciu workbook.ToDataSet() dla pełnego dostępu do DataSet
  • Zapisz zawartość DataTable z powrotem do XLSX iterując wartości DataRow z SetCellValue
  • Powiąż DataTable z kontrolkami UI jak DataGridView za pomocą jednego przypisania DataSource
  • Zasil SqlBulkCopy bezpośrednio z DataTable przy użyciu dużych wstawek bazy danych

Aby pogłębić swoje umiejętności w zakresie IronXL, zapoznaj się z następującymi powiązanymi tematami:

Zacznij od bezpłatnej licencji próbnej IronXL, aby uruchomić te przykłady we własnych projektach. Gdy będziesz gotowy do wdrożenia, kup licencję produkcyjną lub skontaktuj się z zespołem, aby uzyskać wskazówki dotyczące licencjonowania.

Zacznij z IronXL teraz.
green arrow pointer

Często Zadawane Pytania

Jak mogę wyeksportować dane z Excela do tabeli danych (DataTable) w języku C# przy użyciu biblioteki IronXL?

Można wyeksportować dane z Excela do obiektu DataTable w języku C# za pomocą biblioteki IronXL, ładując plik Excel do IronXL, wybierając arkusz lub zakres, a następnie używając metody ExportToDataTable do konwersji danych na obiekt DataTable.

Jakie są zalety konwersji danych z Excela do tabeli danych (DataTable)?

Konwersja danych z Excela do tabeli danych (DataTable) zapewnia uporządkowane dane, które idealnie nadają się do operacji na bazach danych, powiązania danych z kontrolkami interfejsu użytkownika oraz płynnej integracji z platformą .NET. Ułatwia to również manipulowanie danymi i ich przetwarzanie w aplikacjach napisanych w języku C#.

Czy IronXL obsługuje zarówno import, jak i eksport danych między Excelem a DataTable?

Tak, IronXL sprawnie obsługuje zarówno importowanie danych z Excela do DataTable, jak i eksportowanie danych z DataTable do Excela, co czyni go wszechstronnym narzędziem do zarządzania wymianą danych w aplikacjach C#.

Czy za pomocą IronXL można przekonwertować określone zakresy w arkuszu Excel na tabelę danych (DataTable)?

Tak, IronXL pozwala na zaznaczenie określonych zakresów w arkuszu Excel i przekształcenie ich w tabelę danych (DataTable), co zapewnia elastyczność w manipulowaniu danymi i ich pozyskiwaniu.

Czy muszę mieć zainstalowany pakiet Microsoft Office, aby korzystać z IronXL do konwersji danych z Excela?

Nie, nie musisz mieć zainstalowanego pakietu Microsoft Office na swoim komputerze, aby korzystać z IronXL do konwersji danych z Excela do DataTable lub odwrotnie. IronXL działa niezależnie od pakietu Microsoft Office.

Jakie typy danych można konwertować z Excela do DataTable za pomocą IronXL?

IronXL może konwertować różne typy danych z Excela, w tym liczby, tekst, daty i formuły, do formatu DataTable, zachowując integralność i strukturę danych.

Czy IronXL może wyeksportować tabelę danych z powrotem do pliku Excel?

Tak, IronXL może eksportować tabelę danych z powrotem do pliku Excel, umożliwiając generowanie raportów lub tworzenie rozwiązań do przechowywania danych bezpośrednio z aplikacji napisanych w języku C#.

Curtis Chau
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie