Ikona wiadomości
Przejdź do treści stopki
  1. Iron Software
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Eksportuj tabelę danych Excel
KORZYSTANIE Z IRONXL

Eksportuj Excel DataTable w C# | Konwersja danych Excel

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Eksportowanie danych z Excela do DataTable zapewnia uporządkowany, pamięciowy dostęp do zawartości arkusza kalkulacyjnego, który naturalnie współpracuje z bazami danych, kontrolkami interfejsu użytkownika i zapytaniami LINQ. Odwrotny kierunek — zapisanie DataTable z powrotem do pliku Excel — jest równie ważny dla procesów generowania raportów i przechowywania 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
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

Po zainstalowaniu typy WorkBook i WorkSheet udostępniają metody ToDataTable i ToDataSet, które są bezpośrednio mapowane na struktury System.Data. Można również odwrócić ten proces, wpisując wartości DataRow z powrotem do arkusza i zapisując 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 potraktować pierwszy wiersz jako nagłówki kolumn, dzięki czemu nazwy kolumn w wynikowej tabeli będą dokładnie odpowiadać nagłówkom arkusza kalkulacyjnego.

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 odczytuje plik XLSX bez żadnej automatyzacji pakietu Office. worksheet.ToDataTable(true) iteruje każdą komórkę w arkuszu i mapuje ją do DataRow, używając pierwszego wiersza jako nazw DataColumn. Wynikowy DataTable jest standardowym obiektem System.Data — można go powiązać z DataGridView, przekazać do SqlBulkCopy lub natychmiast wykonać na nim zapytania LINQ.

Wywołanie ToDataTable obsługuje zarówno formaty XLS, jak i XLSX, więc ten sam kod działa w starszych arkuszach kalkulacyjnych bez konieczności 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

Dłączego wybór zakresu ma znaczenie

Składnia nawiasów worksheet["A1:D20"] zwraca obiekt IronXl.Range. Wywołanie funkcji ToDataTable w tym zakresie ogranicza przetwarzanie dokładnie do tych komórek, co oznacza szybsze wykonanie i mniejsze zużycie pamięci, gdy plik źródłowy zawiera dziesiątki tysięcy wierszy.

Można również określić nazwane zakresy lub dynamicznie tworzyć ciąg zakresu w czasie wykonywania — na przykład $"A1:D{lastRow}" — co sprawia, że podejście to jest elastyczne w przypadku 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?

Zeszyty robocze z wieloma arkuszami są naturalnie mapowane 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 element DataTable w zwróconym DataSet wykorzystuje oryginalną nazwę arkusza jako swoją właściwość TableName, dzięki czemu można pobrać konkretny arkusz za pomocą dataSet.Tables["Summary"] zamiast iterować 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. Gdy trzeba zapisać dane strukturalne z powrotem w arkuszu kalkulacyjnym — na potrzeby raportów, pobrań lub archiwizacji — należy utworzyć nowy skoroszyt, wypełnić komórki z DataTable i zapisać.

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łówkowego oraz surowe wartości komórek dla wierszy danych bez żadnej konwersji typów. Przesunięcie wiersza row + 1 rezerwuje wiersz 0 dla nagłówków. 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 eksportowania arkusza Excel do DataTable jest wyświetlenie go w oknie Windows Forms DataGridView. Gdy już masz DataTable, powiązanie to tylko jedna linijka 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 powoduje, że DataGridView odczytuje nazwy kolumn i dane wierszy z DataTable. Każdy DataColumn staje się kolumną tabeli, 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.

Ten wzorzec działa równie dobrze z WPF DataGrid, ASP.NET GridView i każdą inną infrastrukturą powiązania 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 przekonwertowaniu arkusza na DataTable można uruchamiać zapytania LINQ przy użyciu metody rozszerzenia AsEnumerable(), która przekształca każdy DataRow w element, na którym można wykonywać zapytania.

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

Dłączego 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 typów w przejrzysty sposób, wyrzucając wyjątek InvalidCastException, jeśli wartość nie może zostać przekonwertowana, zamiast zwracać cichą wartość null. 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 eksportowanym DataTable, co odpowiada standardowemu zachowaniu ADO.NET, dzięki czemu istniejący kod obsługi 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 tworzą puste komórki, zachowując wierność danych w obie strony. Jeśli potrzebujesz domyślnego ciągu znaków dla pól o wartości null, zastąp DBNull.Value swoim symbolem zastępczym 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 ostatnio używany wiersz za pomocą worksheet.RowCount, a następnie przejdź przez zakresy o stałym rozmiarze — na przykład 1000 wierszy na raz — i przetwarzaj każdą partię przed przejściem do następnej.

Właściwości worksheet.RowCount i worksheet.ColumnCount pozwalają tworzyć dynamiczne ciągi znaków zakresu bez konieczności sztywnego 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?

Po uzyskaniu DataTable, wstawienie go do SQL Server za pomocą SqlBulkCopy jest najszybszym sposobem w przypadku dużych zbiorów danych. SqlBulkCopy przyjmuje bezpośrednio DataTable i przesyła wiersze partiami bez tworzenia poszczególnych instrukcji INSERT.

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

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

string connectionCiąg znaków = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

using SqlConnection connection = new(connectionCiąg znaków);
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 connectionCiąg znaków = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

using SqlConnection connection = new(connectionCiąg znaków);
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 connectionCiągZnaków As String = "Server=.;Database=OrdersDB;Trusted_Connection=True;"

Using connection As New SqlConnection(connectionCiągZnaków)
    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 dopasowuje nazwy kolumn DataTable do nazw kolumn w bazie danych. Jeśli obie nazwy są identyczne, można pominąć indywidualne mapowania, a SqlBulkCopy zostanie automatycznie dopasowane na podstawie nazwy. 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.

W przypadku projektów opartych na Entity Framework należy najpierw przekonwertować wiersze DataTable na obiekty modelu typowanego, a następnie użyć DbContext.BulkInsert z biblioteki takiej jak EFCore.BulkExtensions do wstawiania partii danych z obsługą ORM. Dokumentacja Microsoftu dotycząca SqlBulkCopy szczegółowo wyjaśnia opcje przetwarzania wsadowego i obsługę transakcji.

Jakie są Twoje kolejne kroki?

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

  • Konwersja pełnego arkusza z worksheet.ToDataTable(true) w celu eksportu z uwzględnieniem nagłówków
  • Eksportuj określony zakres komórek za pomocą składni worksheet["A1:D20"].ToDataTable(true)
  • Konwertuj skoroszyty wielarkuszowe za pomocą workbook.ToDataSet(), aby uzyskać pełny dostęp do DataSet
  • Zapisz zawartość DataTable z powrotem do pliku XLSX, iterując wartości DataRow za pomocą SetCellValue
  • Powiąż DataTable z kontrolkami interfejsu użytkownika, takimi jak DataGridView, za pomocą pojedynczego przypisania DataSource
  • Przesyłaj dane bezpośrednio z DataTable do SqlBulkCopy w celu wstawiania danych do bazy danych z dużą przepustowością

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.

!{--01001100010010010100001001010010010000010101001001011001010111110100011101000101010101000101111101010011010101000100000101010010010101000100010101000100010111110101011101001001010100010010000101111101010000010100100100111101000100010101010100001101010100010111110101010001010010010010010100000101001100010111110100001001001100010011110100001101001011--}

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

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