Didn’t find what you were looking for?
Ikona wiadomości
Przejdź do treści stopki
  1. Iron Software
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Eksport do Excel Interop
KORZYSTANIE Z IRONXL

Jak eksportować DataTable do Excel w C# używając Interop vs IronXL

Curtis Chau
Curtis Chau
Zaktualizowano:

Dlaczego eksportowanie tabeli danych do programu Excel ma znaczenie dla programistów .NET?

Eksportowanie danych z bazy danych lub aplikacji do pliku Excel jest podstawowym wymogiem dla organizacji, które muszą efektywnie analizować, wizualizować i udostępniać informacje. Pliki Excel są powszechnie znane ze swojego przyjaznego dla użytkownika interfejsu, który ułatwia użytkownikom końcowym interakcję z danymi i ich interpretację. Konwertując zbiory danych do formatu .xlsx, programiści zapewniają, że dane pozostaną dostępne i dobrze ustrukturyzowane, niezależnie od technicznego zaawansowania odbiorcy.

W przypadku programistów .NET istnieją dwa popularne podejścia: Interop Microsoft Office oraz dedykowane biblioteki Excel, takie jak IronXL. W niniejszym przewodniku omówiono obie metody wraz z działającymi przykładami kodu w języku C#, porównano ich zalety i wady oraz wyjaśniono, kiedy każde z tych podejść ma sens w przypadku aplikacji produkcyjnych.

Jakie są kluczowe różnice między Interop a IronXL?

Zanim zagłębimy się w kod, zrozumienie podstawowych różnic między tymi dwoma podejściami pomoże w podjęciu właściwej decyzji dotyczącej każdego projektu. Porównanie obejmuje architekturę techniczną, wymagania dotyczące wdrożenia oraz praktyczne doświadczenia programistyczne związane z eksportowaniem danych z DataTable do Excela.

Porównanie Interop Microsoft Office i IronXL pod kątem eksportu do Excela w języku C#
Funkcja Interop Microsoft Office IronXL
Wymagana instalacja pakietu Office Tak — program Microsoft Excel musi być zainstalowany Nie — biblioteka samodzielna
Obsługa po stronie serwera Niezalecane przez firmę Microsoft W pełni obsługiwane
Obsługa platform Tylko dla systemu Windows Windows, Linux, macOS, Azure
Obsługa .NET Core / .NET 5+ Ograniczone Pełna obsługa (.NET 6, 7, 8, 9, 10)
Zarządzanie zasobami Wymaga czyszczenia obiektów COM Standardowe usuwanie w .NET Standard
Metoda instalacji Odwołanie do COM + instalacja pakietu Office Pakiet NuGet
Model wątków Pojedynczy wątek apartamentowy (STA) Operacje bezpieczne dla wątków
Duże zbiory danych Proces wymagający dużej ilości pamięci Wydajne podejście oparte na plikach
Obsługiwane formaty plików XLSX, XLS, CSV XLSX, XLS, CSV, JSON, XML
Licencjonowanie Wymagana jest licencja Office Dostępna jest licencja komercyjna

Różnica architektoniczna jest zasadnicza: Excel Interop automatyzuje samą aplikację Microsoft Excel za pośrednictwem COM, podczas gdy IronXL odczytuje i zapisuje formaty plików Excel bezpośrednio, bez uruchamiania żadnego zewnętrznego procesu. Ta różnica ma wpływ na wszystko, od wykorzystania pamięci po złożoność wdrożenia.

Jak zainstalować IronXL for Excel Export?

Instalacja IronXL zajmuje tylko kilka sekund za pośrednictwem NuGet. Nie jest wymagane żadne dodatkowe oprogramowanie, instalacja pakietu Office ani konfiguracja systemu. Biblioteka działa natychmiast po instalacji w systemach Windows, Linux i macOS, w tym w usługach Azure App Services, Azure Functions i instancjach kontenerów.

Otwórz konsolę NuGet Package Manager Console i uruchom:

Install-Package IronXL.Excel

IronXL obsługuje .NET Framework 4.6.2+ i wszystkie nowoczesne wersje .NET aż do .NET 10. Po zainstalowaniu, dodaj using IronXL; na początku swojego pliku i gotowe do eksportu.

Jak eksportować DataTable do Excela w C# za pomocą Interop?

Tradycyjne podejście używa przestrzeni nazw Microsoft.Office.Interop.Excel do bezpośredniej automatyzacji Excela. Ta metoda wymaga zainstalowania programu Microsoft Excel na komputerze, na którym działa kod.

Wymagania wstępne dla Interop

Przed użyciem Interop upewnij się, że:

  1. Program Microsoft Excel jest zainstalowany na komputerach służących do programowania i wdrażania.
  2. W programie Visual Studio dodano odwołanie COM do "Biblioteki obiektów programu Microsoft Excel".
  3. Przestrzeń nazw Microsoft.Office.Interop.Excel jest dołączona do twojego projektu.

Kod eksportu Interop

Poniższy kod pokazuje, jak eksportować DataTable do pliku Excel używając Interop Microsoft Office w C# z instrukcjami górnego poziomu:

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }

    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    workbook.Close();
    excelApp.Quit();
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }

    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    workbook.Close();
    excelApp.Quit();
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
Imports Microsoft.Office.Interop.Excel
Imports System.Data
Imports System.Runtime.InteropServices

' Create a sample DataTable with employee data
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

dt.Rows.Add(1, "John Smith", "Engineering", 75000)
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
dt.Rows.Add(3, "Michael Chen", "Finance", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

' Initialize Excel Application object
Dim excelApp As New Application With {
    .Visible = False,
    .DisplayAlerts = False
}

Dim workbook As Workbook = excelApp.Workbooks.Add()
Dim worksheet As Worksheet = CType(workbook.ActiveSheet, Worksheet)

Try
    ' Write column headers to the first row
    For i As Integer = 0 To dt.Columns.Count - 1
        worksheet.Cells(1, i + 1) = dt.Columns(i).ColumnName
    Next

    ' Write data rows starting from row 2
    For i As Integer = 0 To dt.Rows.Count - 1
        For j As Integer = 0 To dt.Columns.Count - 1
            worksheet.Cells(i + 2, j + 1) = dt.Rows(i)(j).ToString()
        Next
    Next

    Dim filePath As String = "C:\Reports\EmployeeReport_Interop.xlsx"
    workbook.SaveAs(filePath)
    Console.WriteLine("Excel file created using Interop.")
Catch ex As Exception
    Console.WriteLine("Error: " & ex.Message)
Finally
    ' Always release COM objects to prevent orphaned Excel processes
    workbook.Close()
    excelApp.Quit()
    Marshal.ReleaseComObject(worksheet)
    Marshal.ReleaseComObject(workbook)
    Marshal.ReleaseComObject(excelApp)
End Try
$vbLabelText   $csharpLabel

Obiekt Application reprezentuje sam proces Excel. Ustawienie Visible = false zapobiega otwarciu Excela na ekranie podczas przetwarzania, co jest niezbędne dla operacji w tle. Ustawienie DisplayAlerts = false tłumi okna dialogowe, które w innym przypadku przerwałyby zautomatyzowane przepływy pracy.

Blok finally nie jest opcjonalny -- musi jawnie zwolnić każdy obiekt COM przy użyciu Marshal.ReleaseComObject. Pominięcie tego kroku powoduje pozostawienie osieroconych procesów Excel w Menedżerze zadań, co zużywa pamięć i ostatecznie destabilizuje serwer. Ten wzorzec czyszczenia jest dobrze znanym problemem, który sprawia, że Interop nie nadaje się do aplikacji i usług internetowych.

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

IronXL stanowi nowoczesną alternatywę, która działa bez konieczności instalowania pakietu Office. Biblioteka odczytuje i zapisuje pliki Excel bezpośrednio, dzięki czemu idealnie nadaje się do środowisk serwerowych, wdrożeń w chmurze i aplikacji wielopłatformowych. Zapoznaj się z pełną dokumentacją IronXL, aby uzyskać dodatkowe informacje na temat API.

Kod eksportu IronXL

Poniższy kod pokazuje, jak konwertować DataTable do pliku Excel używając biblioteki IronXL z instrukcjami górnego poziomu:

using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using IronXL.");
using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using IronXL.");
Imports IronXL
Imports System.Data

' Create a sample DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

dt.Rows.Add(1, "John Smith", "Engineering", 75000)
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
dt.Rows.Add(3, "Michael Chen", "Finance", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

' Create a new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Write column headers to row 0
For i As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, i, dt.Columns(i).ColumnName)
Next

' Export DataTable rows to Excel cells
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

Dim filePath As String = "C:\Reports\EmployeeReport_IronXL.xlsx"
workbook.SaveAs(filePath)
Console.WriteLine("Excel file created using IronXL.")
$vbLabelText   $csharpLabel

Podejście IronXL opiera się na podobnej strukturze logicznej, ale charakteryzuje się bardziej przejrzystą składnią i brakiem złożoności COM. Metoda WorkBook.Create inicjalizuje nowy skoroszyt w określonym formacie -- ExcelFileFormat.XLSX tworzy nowoczesne pliki Office Open XML zgodne z Excel 2007 i nowszymi. Biblioteka obsługuje również format XLS dla starszych systemów.

SetCellValue używa indeksów zaczynających się od 0 zgodnych ze standardowymi konwencjami .NET, co redukuje błędy z przeszukiwaniem indeksów, które często występują przy konwersji między systemami indeksowymi. Metoda automatycznie obsługuje konwersję typów: wartości integer, string, decimal i DateTime są zapisywane z odpowiednimi typami komórek Excel.

Zwróć uwagę na całkowity brak kodu porządkującego. Obiekty IronXL to standardowe obiekty zarządzane w środowisku .NET, którymi automatycznie zajmuje się moduł czyszczący pamięć. Nie ma ryzyka związanego z procesami osieroconymi ani liczeniem odwołań COM, którymi trzeba by się zajmować.

Jak eksportować DataTable do Excel C# używając Interop vs IronXL: Obraz 1 - Wydruk Excel

Jak eksportować DataTable do Excel C# używając Interop vs IronXL: Obraz 2 - Wydruk konsolowy

Więcej informacji na temat tworzenia skoroszytów można znaleźć w przewodniku IronXL dotyczącym tworzenia arkuszy kalkulacyjnych.

Jak stworzyć metodę eksportu wielokrotnego użytku?

Aplikacje produkcyjne często potrzebują metody wielokrotnego użytku, która może eksportować dowolny DataTable do pliku Excel. Przykład poniżej pokazuje pomocnika, który kapsułkuje logikę eksportu, obsługuje wartości null i automatycznie tworzy katalog wyjściowy, jeśli nie istnieje. Zobacz stronę z przykładami IronXL dla większej ilości wzorców.

Wielokrotnego użytku IronXL Export Helper

using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold headers in the first row
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            var cell = sheet.GetCellAt(0, i);
            cell.Value = dt.Columns[i].ColumnName;
            cell.Style.Font.Bold = true;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        FileInfo fileInfo = new FileInfo(filePath);
        if (!fileInfo.Directory!.Exists)
            fileInfo.Directory.Create();

        workbook.SaveAs(filePath);
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine("Export failed: " + ex.Message);
        return false;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold headers in the first row
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            var cell = sheet.GetCellAt(0, i);
            cell.Value = dt.Columns[i].ColumnName;
            cell.Style.Font.Bold = true;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        FileInfo fileInfo = new FileInfo(filePath);
        if (!fileInfo.Directory!.Exists)
            fileInfo.Directory.Create();

        workbook.SaveAs(filePath);
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine("Export failed: " + ex.Message);
        return false;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO

' --- ExcelExporter helper ---

Function ExportToExcel(dt As DataTable, filePath As String) As Boolean
    If dt Is Nothing OrElse dt.Rows.Count = 0 Then
        Return False
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet(If(dt.TableName, "Sheet1"))

        ' Bold headers in the first row
        For i As Integer = 0 To dt.Columns.Count - 1
            Dim cell = sheet.GetCellAt(0, i)
            cell.Value = dt.Columns(i).ColumnName
            cell.Style.Font.Bold = True
        Next

        ' Data rows
        For i As Integer = 0 To dt.Rows.Count - 1
            For j As Integer = 0 To dt.Columns.Count - 1
                Dim value = dt.Rows(i)(j)
                sheet.SetCellValue(i + 1, j, If(value Is DBNull.Value OrElse value Is Nothing, "", value))
            Next
        Next

        Dim fileInfo As New FileInfo(filePath)
        If Not fileInfo.Directory.Exists Then
            fileInfo.Directory.Create()
        End If

        workbook.SaveAs(filePath)
        Return True
    Catch ex As Exception
        Console.WriteLine("Export failed: " & ex.Message)
        Return False
    End Try
End Function

' --- Usage ---

Dim employees As New DataTable("Employees")
employees.Columns.Add("EmployeeID", GetType(Integer))
employees.Columns.Add("Name", GetType(String))
employees.Columns.Add("Department", GetType(String))
employees.Rows.Add(1, "John Smith", "Engineering")
employees.Rows.Add(2, "Sarah Johnson", "Marketing")

Dim success As Boolean = ExportToExcel(employees, "C:\Reports\Export.xlsx")
Console.WriteLine(If(success, "Export completed.", "Export failed."))
$vbLabelText   $csharpLabel

Pomocnik ExportToExcel akceptuje dowolny DataTable i ciąg ścieżki pliku, zwracając false jeśli eksport się nie powiedzie lub tabela jest pusta. Obsługuje brakujące wartości w elegancki sposób, sprawdzając DBNull.Value przed zapisaniem komórek. Krok tworzenia katalogu zapobiega zakłócaniu DirectoryNotFoundException zaplanowanych eksportów do nowych ścieżek folderów -- powszechny problem produkcyjny podczas wdrażania w nowe środowiska.

Nagłówki pisane są pogrubioną czcionką przy użyciu cell.Style.Font.Bold = true, co generuje profesjonalnie wyglądający wynik bez dodatkowej konfiguracji. Szablon można łatwo rozszerzyć: dodaj kolory tła, obramowania lub automatyczne dopasowanie szerokości kolumn, aby dostosować go do standardów raportowania obowiązujących w Twojej organizacji.

W przypadku pracy z dużymi zbiorami danych przewodnik wydajności IronXL omawia strategie masowego zapisu, które minimalizują alokację pamięci. Biblioteka obsługuje także eksport DataSet -- kolekcji powiązanych obiektów DataTable -- na wiele arkuszy w pojedynczym skoroszycie, co jest przydatne do raportów wieloarkuszowych.

W jaki sposób oba podejścia radzą sobie z formatowaniem komórek?

Profesjonalne eksporty do programu Excel często wymagają formatowania: pogrubionych nagłówków, kolorowych komórek, obramowań i formatów liczb. Obie biblioteki obsługują stylizację, ale ich implementacja znacznie różni się pod względem rozbudowania i niezawodności.

Formatowanie za pomocą IronXL

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

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write headers with light blue background and bold font
for (int i = 0; i < dt.Columns.Count; i++)
{
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
using IronXL;
using IronXL.Styles;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write headers with light blue background and bold font
for (int i = 0; i < dt.Columns.Count; i++)
{
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
Imports IronXL
Imports IronXL.Styles
Imports System.Data

Dim dt As New DataTable("Sales")
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Revenue", GetType(Decimal))
dt.Rows.Add("Widget A", 15000.50D)
dt.Rows.Add("Widget B", 22500.75D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

' Write headers with light blue background and bold font
For i As Integer = 0 To dt.Columns.Count - 1
    Dim cell = sheet.GetCellAt(0, i)
    cell.Value = dt.Columns(i).ColumnName
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#ADD8E6")
    cell.Style.BottomBorder.SetColor("#000000")
    cell.Style.BottomBorder.Type = BorderType.Thin
Next

' Write data rows
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

workbook.SaveAs("C:\Reports\FormattedReport_IronXL.xlsx")
Console.WriteLine("Formatted Excel file created.")
$vbLabelText   $csharpLabel

API stylizacji IronXL wykorzystuje przejrzysty model obiektowy. Wartości kolorów akceptują standardowe kody hex, takie jak #ADD8E6 (jasnoniebieski), dzięki czemu łatwo jest dopasować się do markowej kolorystyki, unikając konwersji między systemami kolorów. BorderType.Thin i BorderType.Thick pokrywają standardowe scenariusze z obramowaniami, bez potrzeby przeszukiwania enumeracji.

Jak eksportować DataTable do Excel C# używając Interop vs IronXL: Obraz 3 - Formatowanie z wynikiem IronXL

Wszystkie opcje stylizacji, w tym formaty liczb, formatowanie warunkowe i scałanie komórek, można znaleźć w przewodniku po stylizacji komórek IronXL oraz w dokumentacji dotyczącej obramowań i wyrównania.

Złożoność formatowania Interop

Ekwiwalent Interopu uzyskuje dostęp do pojedynczych obiektów Range i ustawia właściwości takie jak Font.Bold, Interior.Color, i Borders.LineStyle. Każde uzyskanie dostępu do właściwości jest wywołaniem międzyprocesowym COM, co dodaje obciążenie i zwiększa prawdopodobieństwo wyjątków, jeśli Excel przestaje odpowiadać. Wartości kolorów wymagają konwersji System.Drawing.ColorTranslator.ToOle, a każdy blok stylizacji musi być zakończony standardowym łańcuchem czyszczenia COM -- co najmniej trzykrotne wywołanie Marshal.ReleaseComObject.

Ta rozbudowana forma staje się problematyczna przy stosowaniu formatowania warunkowego, szerokości kolumn lub formatów liczb w dużych arkuszach. IronXL obsługuje te same scenariusze przy użyciu mniejszej liczby linii kodu i bez ryzyka pozostawienia uruchomionych procesów Excela po awarii.

Jakie są najlepsze praktyki dotyczące eksportu do Excela w .NET?

Stosowanie spójnych praktyk we wszystkich procedurach eksportu zmniejsza liczbę błędów, poprawia łatwość utrzymania oraz ułatwia testowanie i wdrażanie kodu.

Konwencje nazewnictwa i ścieżek

Użyj spójnej konwencji nazewniczej dla eksportowanych plików: {ReportName}_{Timestamp}.xlsx. Przewidywalne nazwy plików ułatwiają automatyczne porządkowanie i archiwizację. Przechowuj katalog wyjściowy w konfiguracji aplikacji zamiast bezpośredniego kodowania ścieżek -- to zapobiega DirectoryNotFoundException podczas wdrażania w nowe środowiska.

Obsługa błędów

Całą logikę eksportu należy umieścić w blokach try-catch i rejestrować wyjątki wraz z wystarczającym kontekstem, aby umożliwić diagnozę błędu. W przypadku zaplanowanych eksportów warto rozważyć zwracanie obiektu wynikowego zamiast generowania wyjątków, aby wywołująca usługa mogła ponowić próbę lub powiadomić operatorów bez powodowania awarii. Pomocnik ExportToExcel powyżej pokazuje ten wzorzec z wartością zwracaną bool.

Obsługa dużych zbiorów danych

W przypadku zbiorów danych zawierających ponad 50 000 wierszy należy przesyłać dane partiami, aby uniknąć obciążenia pamięci. IronXL obsługuje zapis progresywny, a OpenXML SDK oferuje strumieniowanie niskopoziomowe dla bardzo dużych plików. Należy całkowicie unikać Interop w przypadku dużych zbiorów danych — jego model pamięciowy powoduje znaczne spowolnienia przy dużej skali.

Wdrażanie wielopłatformowe

Jeśli aplikacja działa w systemie Linux lub macOS — na przykład w kontenerach Docker lub usługach Azure Linux App Services — IronXL jest jedynym realnym wyborem. Interop nie działa poza systemem Windows, ponieważ jest zależny od serwera COM programu Excel. Skorzystaj z przewodnika po wdrażaniu wielopłatformowym .NET, aby sprawdzić, czy wszystkie zależności są dostępne w docelowym środowisku uruchomieniowym.

Testowanie

Testy jednostkowe logiki eksportu powinny weryfikować, czy plik wyjściowy istnieje, zawiera oczekiwaną liczbę wierszy i używa prawidłowych nazw kolumn. Metoda WorkBook.Load IronXL ułatwia odczyt zaimportowanych plików w testach bez uruchamiania Excela. Przykłady można znaleźć w przewodniku IronXL.

Kiedy należy wybrać poszczególne podejścia?

Właściwy wybór zależy od konkretnych wymagań projektu, środowiska wdrożeniowego oraz kwestii związanych z długoterminową konserwacją.

Wybierz Microsoft Office Excel Interop, gdy:

  • Praca z istniejącymi systemami, które już opierają się na Interop, oraz migracja nie są możliwe.
  • Zaawansowane funkcje programu Excel, takie jak makra, tabele przestawne lub automatyzacja wykresów, wymagają pełnego modelu obiektowego aplikacji Excel.
  • Tworzenie aplikacji desktopowych, w których użytkownicy mają zainstalowany program Microsoft Excel, a aplikacja działa w trybie interaktywnym.
  • Środowisko wdrożeniowe jest w pełni kontrolowane, działa wyłącznie w systemie Windows, a licencje na pakiet Office są już dostępne.
  • Automatyzacja istniejących szablonów Excel zawierających złożone wbudowane formuły lub kod VBA.

Wybierz IronXL, gdy:

  • Tworzenie aplikacji internetowych, interfejsów API REST lub usług działających w tle, które generują eksporty do plików Excel.
  • Wdrażanie w środowiskach chmurowych, takich jak Azure App Services, AWS Lambda lub kontenery Docker.
  • Wymagana obsługa wielu platform dla wdrożeń w systemach Windows, Linux lub macOS.
  • Praca z .NET Framework 4.6.2+ lub nowszymi wersjami .NET, w których obsługa Interop jest ograniczona.
  • Potrzeba niezawodnego zarządzania zasobami bez obaw o czyszczenie COM.
  • Unikanie zależności licencyjnych pakietu Office na serwerach produkcyjnych.
  • Tworzenie aplikacji wielodostępnych, w których wymagane jest generowanie izolowanych plików Excel.
  • Efektywne przetwarzanie dużych zbiorów danych bez obciążenia związanego z komunikacją międzyprocesową COM.
  • Konieczność eksportowania do wielu formatów, w tym XLSX, XLS, CSV, JSON i XML.

Zapoznaj się z samouczkami IronXL, aby poznać dodatkowe scenariusze, w tym odczytywanie istniejących plików Excel, pracę z formułami oraz zarządzanie wieloma arkuszami.

Jakie są Twoje kolejne kroki?

Eksportowanie DataTable do pliku Excel jest podstawowym wymogiem aplikacji .NET obsługujących dane biznesowe. Niezależnie od tego, czy źródłem jest zapytanie do bazy danych, DataSet z wieloma powiązanymi tabelami, czy dynamicznie zbudowana kolekcja w pamięci, wybór odpowiedniej biblioteki decyduje o elastyczności wdrażania i długoterminowym utrzymaniu.

Microsoft Office Excel Interop służy programistom od lat, ale jego zależność od instalacji pakietu Office, złożoność interfejsu COM, brak obsługi niektórych scenariuszy serwerowych oraz wyzwania związane z zarządzaniem zasobami sprawiają, że staje się on coraz mniej praktyczny w nowoczesnym tworzeniu aplikacji.

IronXL oferuje bardziej przejrzystą alternatywę, która rozwiązuje te ograniczenia. Dzięki prostej instalacji NuGet, obsłudze wielu platform, w tym Windows, Linux i macOS, oraz prostym interfejsom API zgodnym z konwencjami .NET, eliminuje problemy związane z wdrażaniem i pułapki związane z zarządzaniem zasobami, które dotykają rozwiązania Excel Interop.

Aby rozpocząć, zainstaluj IronXL z NuGet, skopiuj jeden z powyższych przykładów kodu i wykonaj szybki eksport z testowej DataTable. Przewodnik szybkiego startu IronXL w ciągu kilku minut omawia najczęstsze scenariusze. Kiedy będziesz gotowy do wdrożenia, zapoznaj się ze stroną licencyjną IronXL, aby znaleźć opcję dostosowaną do wielkości Twojego zespołu i modelu wdrożenia. Aby uzyskać więcej informacji, zapoznaj się z pełną dokumentacją API IronXL oraz repozytorium IronXL na GitHubie, gdzie znajdziesz przykłady udostępnione przez społeczność.

Często Zadawane Pytania

Jaka jest główna zaleta korzystania z IronXL zamiast Excel Interop do eksportowania tabel danych w języku C#?

IronXL zapewnia prostszy i bardziej wydajny sposób eksportowania tabel danych do programu Excel w języku C# bez konieczności instalowania programu Excel na serwerze.

Czy IronXL radzi sobie z dużymi tabelami danych podczas eksportu do Excela?

Tak, IronXL jest zoptymalizowany pod kątem wydajności i może obsługiwać duże tabele danych, zapewniając szybki i niezawodny eksport do plików Excel.

Czy muszę mieć zainstalowany program Microsoft Excel, aby korzystać z IronXL do eksportowania danych?

Nie, IronXL nie wymaga zainstalowania programu Microsoft Excel, co czyni go idealnym rozwiązaniem dla aplikacji po stronie serwera.

W jaki sposób IronXL upraszcza proces eksportowania tabel danych w porównaniu z Interop?

IronXL upraszcza ten proces, eliminując skomplikowaną konfigurację i zależności związane z Interop, zapewniając proste API do eksportowania tabel danych.

Czy IronXL jest kompatybilny z .NET Core w zakresie eksportowania tabel danych do Excela?

Tak, IronXL jest w pełni kompatybilny z .NET Core, co pozwala na eksportowanie tabel danych do Excela w aplikacjach wielopłatformowych.

Do jakich formatów plików IronXL może eksportować tabele danych?

IronXL może eksportować tabele danych do różnych formatów plików Excel, w tym XLSX, XLS i CSV.

Czy IronXL obsługuje stylizację i formatowanie arkuszy Excel?

Tak, IronXL obsługuje zaawansowane opcje stylizacji i formatowania, umożliwiając tworzenie dopracowanych arkuszy Excel na podstawie tabel danych.

Czy mogę używać IronXL do automatyzacji zadań związanych z Excelem w języku C#?

Tak, IronXL może służyć do automatyzacji szerokiego zakresu zadań związanych z programem Excel, od eksportowania tabel danych po złożone operacje analizy danych.

Czy programiści, którzy dopiero zaczynają korzystać z IronXL, muszą się najpierw wdrożyć?

IronXL został zaprojektowany tak, aby był intuicyjny i łatwy do opanowania, a obszerna dokumentacja i przykłady pomagają programistom szybko rozpocząć pracę.

Jakie są opcje licencyjne dotyczące wykorzystania IronXL w projekcie komercyjnym?

IronXL oferuje różne opcje licencyjne dostosowane do różnych potrzeb projektowych, w tym licencje wieczyste i subskrypcyjne do użytku komercyjnego.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
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

Powiązane artykuły

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

Zespół wsparcia Iron

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