Eksportowanie zestawu danych (DataSet) lub tabeli danych (DataTable) do programu Excel w języku C# zapewnia niezawodny sposób przekształcania ustrukturyzowanych danych przechowywanych w pamięci w profesjonalne pliki arkuszy kalkulacyjnych — bez konieczności instalowania pakietu Microsoft Office na komputerze docelowym. Niezależnie od tego, czy pobierasz rekordy z bazy danych SQL, tworzysz zestaw danych programowo, czy pracujesz z istniejącą siatką danych (DataGrid), IronXL obsługuje cały proces za pomocą przejrzystego interfejsu API opartego na kodzie. W niniejszym przewodniku omówiono wszystkie główne scenariusze — od eksportu pojedynczej tabeli, przez skoroszyty zawierające wiele arkuszy, po wyniki zapytań do bazy danych na żywo — przy użyciu instrukcji C# najwyższego poziomu oraz platformy .NET 10.
Wystarczy raz zainstalować IronXL, napisać kilka linii kodu, a dane znajdą się w pliku XLSX bez żadnej zależności od pakietu Office. Poniższe sekcje obejmują instalację, podstawowe wzorce, zaawansowane formatowanie oraz integrację z bazami danych w sposób umożliwiający bezpośrednie skopiowanie i wklejenie treści do własnych projektów.
Przed napisaniem jakiegokolwiek kodu eksportującego dodaj IronXL do swojego projektu za pomocą menedżera pakietów NuGet. Otworz terminal w katalogu glownym projektu i uruchom komende .NET CLI lub uzyj konsoli Package Manager w Visual Studio z komenda Install-Package:
Lub w Package Manager Console Visual Studio:
Po instalacji dodaj instrukcję using najwyższego poziomu, aby zaimportować przestrzeń nazw IronXL:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataIronXL obsługuje platformy .NET 8, .NET 9 i .NET 10, a także starsze wersje .NET Framework (4.6.2+). Nie jest wymagana instalacja pakietu Office na żadnym komputerze — serwerze, komputerze stacjonarnym ani w chmurze. Po zainstalowaniu pakietu można tworzyć, odczytywać i zapisywać pliki XLSX, XLS i CSV całkowicie w kodzie zarządzanym.
Szczegółowe opcje instalacji można znaleźć w przewodniku instalacji IronXL, a historię wersji na stronie pakietu NuGet.
Najczęstszym scenariuszem jest eksportowanie jednej tabeli danych (DataTable) do pojedynczego arkusza. Klasy WorkBook i WorkSheet z IronXL mapuja sie naturalnie na model obiektowy Excel. Tworzysz skoroszyt, dodajesz arkusz, a następnie iterujesz kolumny i wiersze tabeli danych.
Ponizszy przyklad tworzy Employees DataTable w pamieci i zapisuje go do EmployeeData.xlsx:
using IronXL;
using System.Data;
// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");
// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
// Write data rows starting at row 1
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("EmployeeData.xlsx");Imports IronXL
Imports System.Data
' Build an in-memory DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("ID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Rows.Add(1, "John Smith", "Engineering")
dt.Rows.Add(2, "Sarah Jones", "Marketing")
dt.Rows.Add(3, "Mike Wilson", "Sales")
' Create a workbook and a named worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Write column headers in row 0
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
' Write data rows starting at row 1
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("EmployeeData.xlsx")
SetCellValue akceptuje int, double, string i bool — wiec uzyskujesz natywne typy komorek Excel bez dodatkowego rzutowania. Schemat petli dziala dla tabel dowolnej wielkosci, poniewaz IronXL zapisuje bezposrednio do pamieci i zapisuje na dysk tylko, gdy jest wywolywany SaveAs, co utrzymuje proces efektywnym nawet dla tysiecy wierszy.
Aby uzyskać szerszy obraz technik odczytu i zapisu, samouczek IronXL C# obejmuje pełen zakres operacji na plikach wraz z tym wzorcem eksportu.
Gdy zestaw danych (DataSet) zawiera kilka powiązanych tabel — takich jak "Produkty" i "Zamówienia" — można przypisać każdą tabelę danych (DataTable) do osobnego arkusza w ramach jednego skoroszytu. Dzięki temu odbiorcy mogą przeglądać wszystkie powiązane dane w jednym pliku bez konieczności otwierania wielu dokumentów.
Poniższa petla iteruje ds.Tables i tworzy jeden arkusz na tabele:
using IronXL;
using System.Data;
// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");
DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);
DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);
// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
foreach (DataTable table in ds.Tables)
{
WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);
// Write headers
for (int col = 0; col < table.Columns.Count; col++)
{
sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
}
// Write rows
for (int row = 0; row < table.Rows.Count; row++)
{
for (int col = 0; col < table.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
}
}
}
workbook.SaveAs("CompanyReport.xlsx");Imports IronXL
Imports System.Data
' Build a DataSet with two related tables
Dim ds As New DataSet("CompanyData")
Dim dtProducts As New DataTable("Products")
dtProducts.Columns.Add("ProductID", GetType(Integer))
dtProducts.Columns.Add("ProductName", GetType(String))
dtProducts.Columns.Add("Price", GetType(Decimal))
dtProducts.Rows.Add(101, "Widget A", 29.99D)
dtProducts.Rows.Add(102, "Widget B", 49.99D)
ds.Tables.Add(dtProducts)
Dim dtOrders As New DataTable("Orders")
dtOrders.Columns.Add("OrderID", GetType(Integer))
dtOrders.Columns.Add("Customer", GetType(String))
dtOrders.Columns.Add("Total", GetType(Decimal))
dtOrders.Rows.Add(1001, "Acme Corp", 599.90D)
dtOrders.Rows.Add(1002, "Tech Inc", 299.95D)
ds.Tables.Add(dtOrders)
' Create one workbook and iterate each DataTable
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
For Each table As DataTable In ds.Tables
Dim sheet As WorkSheet = workbook.CreateWorkSheet(table.TableName)
' Write headers
For col As Integer = 0 To table.Columns.Count - 1
sheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next
' Write rows
For row As Integer = 0 To table.Rows.Count - 1
For col As Integer = 0 To table.Columns.Count - 1
sheet.SetCellValue(row + 1, col, table.Rows(row)(col).ToString())
Next
Next
Next
workbook.SaveAs("CompanyReport.xlsx")
Każdy arkusz ma nazwę zgodną z nazwą źródłowej tabeli DataTable, co ułatwia poruszanie się po programie Excel. Poniewaz WorkBook.Create przydziela skoroszyt w pamieci, mozesz nadal dodawac arkusze w petli bez ponownego otwierania pliku — IronXL buduje cala strukture XLSX przed zapisaniem na dysk.
Dokumentacja IronXL WorkBook zawiera listę wszystkich metod dostępnych dla obiektu WorkBook, w tym zmianę kolejności arkuszy, ochronę hasłem oraz zapisywanie w formatach innych niż XLSX.
Eksport zwykłych danych jest funkcjonalny, ale dodanie pogrubionych nagłówków i szerokości kolumn sprawia, że wynik jest od razu użyteczny w kontekście biznesowym. IronXL udostepnia stylizowanie komorek i zakresow dzieki obiektowi Style przypisanemu do dowolnego zakresu WorkSheet.
Poniższy fragment kodu stosuje pogrubienie czcionki w wierszu nagłówkowym i automatycznie dostosowuje rozmiar kolumn po zapisaniu danych:
using IronXL;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));
dt.Rows.Add("Nierth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East", 87000m, 93000m, 99000m, 108000m);
dt.Rows.Add("West", 145000m, 152000m, 161000m, 174000m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
sheet["A1:E1"].Style.Font.Bold = true;
sheet["A1:E1"].Style.Font.Height = 12;
}
// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
}
}
workbook.SaveAs("SalesReport.xlsx");Imports IronXL
Imports System.Data
Dim dt As New DataTable("Sales")
dt.Columns.Add("Region", GetType(String))
dt.Columns.Add("Q1", GetType(Decimal))
dt.Columns.Add("Q2", GetType(Decimal))
dt.Columns.Add("Q3", GetType(Decimal))
dt.Columns.Add("Q4", GetType(Decimal))
dt.Rows.Add("Nierth", 120000D, 135000D, 142000D, 158000D)
dt.Rows.Add("South", 98000D, 104000D, 112000D, 121000D)
dt.Rows.Add("East", 87000D, 93000D, 99000D, 108000D)
dt.Rows.Add("West", 145000D, 152000D, 161000D, 174000D)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")
' Write and style headers
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
sheet("A1:E1").Style.Font.Bold = True
sheet("A1:E1").Style.Font.Height = 12
Next
' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(row + 1, col, dt.Rows(row)(col))
Next
Next
workbook.SaveAs("SalesReport.xlsx")Wlasciwosc Style.Font.Bold dotyczy calego zakresu naglowka w jednym wyrazeniu. IronXL obsluguje rowniez kolory tła (Style.BackgroundColor), style obramowan (Style.Border), formatowanie liczb (Style.NumberFormat.FormatCode) i wyrównanie poziome (Style.HorizontalAlignment). Pełne wytyczne dotyczące stylizacji można znaleźć w przewodniku po formatowaniu komórek IronXL.
Łączenie się z bazą danych SQL i eksportowanie wyników bezpośrednio do Excela obejmuje główny praktyczny przypadek użycia — zaplanowane raporty, migawki danych i eksporty administracyjne. Podejscie wypelnia DataSet uzywajac SqlDataAdapter, a nastepnie mapuje wynikowy DataTable na arkusz IronXL.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";
// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
adapter.Fill(ds, "Customers");
}
DataTable dt = ds.Tables["Customers"]!;
// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");
// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;
// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
object cellValue = dt.Rows[row][col];
worksheet.SetCellValue(row + 1, col,
cellValue == DBNull.Value ? "" : cellValue.ToString()!);
}
}
workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Server=localhost;Database=SalesDB;Integrated Security=True;"
Dim query As String = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers"
' Fill DataSet from SQL query
Dim ds As New DataSet()
Using connection As New SqlConnection(connectionString)
Dim adapter As New SqlDataAdapter(query, connection)
adapter.Fill(ds, "Customers")
End Using
Dim dt As DataTable = ds.Tables("Customers")
' Create workbook and export
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("CustomerData")
' Bold header row
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
worksheet("A1:D1").Style.Font.Bold = True
' Write rows, handling DBNull values safely
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
Dim cellValue As Object = dt.Rows(row)(col)
worksheet.SetCellValue(row + 1, col, If(cellValue Is DBNull.Value, "", cellValue.ToString()))
Next
Next
workbook.SaveAs("CustomerExport.xlsx")
Console.WriteLine("Export complete.")Kontrola wartości null (cellValue == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns NULL wartosci — co jest czestym przypadkiem przy kolumnach opcjonalnych. Pogrubienie w wierszu nagłówkowym pozwala odbiorcom raportu natychmiast odróżnić nagłówki od danych.
Aby uzyskac wiecej wzorcow dotyczacych odczytywania danych z powrotem z Excel do obiektów C#, przewodnik eksportu DataTable IronXL pokazuje, jak odwrócic ten przepływ pracy.
Przed wyborem biblioteki warto zrozumieć, jak główne opcje wypadają w porównaniu ze sobą w obszarach, które mają największe znaczenie dla scenariuszy eksportu zestawów danych.
| Podejście | Wymagane biuro | Obsługa formatu XLSX | Stylizacja API | Wiele arkuszy | Wydajność (duże zbiory danych) |
|---|---|---|---|---|---|
| IronXL | Nie | Tak | Pełna | Tak | Duze |
| Interop Microsoft Office | Tak | Tak | Pełna | Tak | Niski |
| EPPlus | Nie | Tak | Częściowe | Tak | Duze |
| ClosedXML | Nie | Tak | Częściowe | Tak | Srednie |
| CSV (ręcznie) | Nie | Nie | Niene | Nie | Bardzo wysoka |
Interop Microsoft Office działa tylko na komputerach z systemem Windows, na których zainstalowano pakiet Office, co wyklucza jego wykorzystanie w wdrożeniach serwerowych i funkcjach chmury. IronXL, EPPlus i ClosedXML obsługują generowanie po stronie serwera — kluczowym czynnikiem wyróżniającym je jest zakres API stylizacji oraz model licencjonowania. Licencja IronXL obejmuje użytkowanie komercyjne i wszystkie docelowe frameworki .NET w ramach jednego pakietu.
W przypadku testów porównawczych i zestawień przeprowadzonych przez podmioty zewnętrzne dokumentacja Microsoftu dotycząca formatów plików Excel oraz strona projektu EPPlus dostarczają dodatkowego kontekstu, który pomoże w dokonaniu właściwego wyboru dla danego projektu.
Podczas eksportowania tabel danych zawierających dziesiątki tysięcy wierszy ważne jest, aby zużycie pamięci było przewidywalne. Poniższy wzorzec strumieniuje dane z IDataReader zamiast ladowac najpierw caly zestaw wynikow do DataTable. To unika podwojnego obciazenia pamieci utrzymywania bufora czytnika i DataTable jednoczesnie.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");
using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();
using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();
// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
sheet.SetCellValue(0, col, reader.GetName(col));
}
// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
for (int col = 0; col < reader.FieldCount; col++)
{
sheet.SetCellValue(excelRow, col,
reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
}
excelRow++;
}
workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Server=localhost;Database=InventoryDB;Integrated Security=True;"
Dim query As String = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products"
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Inventory")
Using conn As New SqlConnection(connectionString)
conn.Open()
Using cmd As New SqlCommand(query, conn)
Using reader As SqlDataReader = cmd.ExecuteReader()
' Write schema-derived headers
For col As Integer = 0 To reader.FieldCount - 1
sheet.SetCellValue(0, col, reader.GetName(col))
Next
' Stream rows directly into IronXL without buffering a DataTable
Dim excelRow As Integer = 1
While reader.Read()
For col As Integer = 0 To reader.FieldCount - 1
sheet.SetCellValue(excelRow, col, If(reader.IsDBNull(col), "", reader.GetValue(col).ToString()))
Next
excelRow += 1
End While
workbook.SaveAs("InventoryExport.xlsx")
Console.WriteLine($"Exported {excelRow - 1} rows.")
End Using
End Using
End UsingTen wzorzec jest zalecany, gdy zestaw wyników może przekroczyć 50 000 wierszy lub gdy jest uruchamiany w ramach usługi o ograniczonej pamięci. Dokumentacja dotycząca wydajności IronXL obejmuje dodatkowe opcje dostrajania pamięci i przepustowości dla eksportów o dużej objętości.
W przypadku eksportów przekraczających 500 000 wierszy, gdy pamięć jest bardzo ograniczona, warto rozważyć podzielenie wyników na wiele skoroszytów lub eksportowanie do formatu CSV:
using IronXL;
// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");Imports IronXL
' IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv")Plik CSV traci formatowanie i obsługę wielu arkuszy, ale pozostaje ważny dla dalszych procesów ETL, które wykorzystują surowe dane rozdzielone separatorami.
IronXL obsluguje zapisywanie do sciezki pliku, MemoryStream i byte[], co ma znaczenie dla aplikacji ASP.NET zwracajacych Excel jako odpowiedz do pobrania.
using IronXL;
using System.IO;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");
// Save to file path
workbook.SaveAs("Report.xlsx");
// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");
// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller actionImports IronXL
Imports System.IO
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
sheet.SetCellValue(0, 0, "Generated Report")
' Save to file path
workbook.SaveAs("Report.xlsx")
' Save as XLS (legacy format)
workbook.SaveAs("Report.xls")
' Save to MemoryStream for HTTP response
Using ms As New MemoryStream()
workbook.SaveAs(ms)
Dim fileBytes As Byte() = ms.ToArray()
' fileBytes can be returned from an ASP.NET controller action
End UsingDla ASP.NET Core, zwroc File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") z akcji kontrolera, aby wywolywana byla opcja pobierania przegladarki. Przewodnik IronXL ASP.NET Excel przedstawia kompletny wzorzec integracji kontrolera.
Jeśli chodzi o alternatywne biblioteki .NET dla programu Excel, Open XML SDK to platforma open source, na której opiera się wiele bibliotek.
IronXL zapisuje pliki w następujących formatach bez żadnych dodatkowych zależności:
Przelacz formaty, zmieniajac rozszerzenie pliku w sciezce SaveAs lub korzystajac z przeciazonej metody, ktora akceptuje wartosc ExcelFileFormat enum.
Po wyeksportowaniu pliku można go ponownie odczytać za pomocą IronXL w celu zweryfikowania liczby wierszy, wyrywkowej kontroli wartości lub uruchomienia automatycznych testów w projekcie testowym:
using IronXL;
WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];
// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");
// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;
Console.WriteLine($"Header: {header}, First row: {firstEmployee}");Imports IronXL
Dim loaded As WorkBook = WorkBook.Load("EmployeeData.xlsx")
Dim sheet As WorkSheet = loaded.WorkSheets(0)
' Verify row count (header row + data rows)
Dim totalRows As Integer = sheet.Rows.Count()
Console.WriteLine($"Rows in file: {totalRows}")
' Spot-check specific cell values
Dim header As String = sheet("A1").StringValue
Dim firstEmployee As String = sheet("A2").StringValue
Console.WriteLine($"Header: {header}, First row: {firstEmployee}")Ten wzorzec weryfikacji jest szczególnie przydatny w Suite testów integracyjnych, gdzie przed wysłaniem plików do systemów zewnętrznych należy potwierdzić poprawność eksportu. Przewodnik czytania IronXL pokazuje pełen zakres operacji odczytu dostępnych po załadowaniu pliku.
Więcej informacji na temat wzorców DataSet i DataTable w .NET można znaleźć w dokumentacji Microsoft DataSet, która szczegółowo omawia model obiektowy ADO.NET.
Masz teraz gotowe wzorce dla każdego głównego scenariusza eksportu z DataSet do Excela w C# — od pojedynczej tabeli DataTable po skoroszyty z wieloma arkuszami, eksporty oparte na bazach danych, sformatowane nagłówki i strumieniowanie dużych zbiorów danych. Oto jak wykonać kolejny krok w zależności od celu:
Opierając się na omówionych tutaj wzorcach, można w pełni zintegrować automatyzację zaplanowanych zadań, punkty końcowe pobierania ASP.NET Core oraz wieloformatowe potoki wyjściowe w zarządzanym języku C# — bez Office, bez COM, bez zależności środowiskowych poza pakietem NuGet.
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ęczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
