C# Eksportuj obiekt listy do Excel

Dlaczego eksportowanie list do plików Excel stanowi wyzwanie?

Tradycyjne metody eksportowania danych do Excela często wymagają użycia Microsoft Office Interop, co wiąże się z koniecznością zainstalowania MS Excel na serwerze i powoduje problemy z wdrożeniem. Ręczne wypełnianie komórek za pomocą refleksji jest czasochłonne i podatne na błędy. Funkcje importu danych IronXL rozwiązują te problemy dzięki inteligentnemu mapowaniu właściwości między źródłami danych a nagłówkami kolumn w Excelu, bez konieczności korzystania z pakietu MS Office lub skomplikowanego kodu refleksyjnego.

Biblioteka automatycznie obsługuje konwersję typów, obsługuje obiekty zagnieżdżone i zachowuje integralność danych w różnych formatach, takich jak pliki CSV i XLSX. Dla programistów pracujących nad operacjami C# w Excelu bez Interop, IronXL jest idealnym wyborem dla nowoczesnych projektów .NET, które wymagają niezawodnego generowania plików Excel oraz funkcji importu i eksportu danych.

Jak zainstalować IronXL?

Rozpoczęcie pracy z IronXL wymaga minimalnej konfiguracji. Zainstaluj bibliotekę za pomocą konsoli NuGet Package Manager Console:

Install-Package IronXL.Excel

Lub użyj interfejsu CLI platformy .NET:

dotnet add package IronXL.Excel

Po zainstalowaniu dodaj dyrektywę using IronXL; do swojego pliku. Nie są wymagane dodatkowe zależności Office ani instalacje uruchomieniowe.

Jak wyeksportować prostą listę do programu Excel?

Poniższy przykład demonstruje eksportowanie listy obiektów Employee do pliku XLSX za pomocą instrukcji najwyższego poziomu, preferowanego stylu w .NET 10:

using IronXL;
using System.Data;

// Define the Employee model
record Employee(int Id, string Name, string Department, decimal Salary, DateTime HireDate);

// Create sample employee data
List<Employee> employees =
[
    new(1, "Alice Johnson", "Engineering", 95000, new DateTime(2020, 3, 15)),
    new(2, "Bob Smith",    "Marketing",   75000, new DateTime(2021, 7, 1)),
    new(3, "Carol Williams","Engineering",105000, new DateTime(2019, 11, 20))
];

// Build a DataTable from the list
DataTable dataTable = new();
dataTable.Columns.Add("Id",         typeof(int));
dataTable.Columns.Add("Name",       typeof(string));
dataTable.Columns.Add("Department", typeof(string));
dataTable.Columns.Add("Salary",     typeof(decimal));
dataTable.Columns.Add("HireDate",   typeof(DateTime));

foreach (var emp in employees)
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate);

// Create an IronXL workbook and worksheet
WorkBook workbook  = new();
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

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

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

// Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx");
Console.WriteLine("EmployeeReport.xlsx saved.");

using IronXL;
using System.Data;

// Define the Employee model
record Employee(int Id, string Name, string Department, decimal Salary, DateTime HireDate);

// Create sample employee data
List<Employee> employees =
[
    new(1, "Alice Johnson", "Engineering", 95000, new DateTime(2020, 3, 15)),
    new(2, "Bob Smith",    "Marketing",   75000, new DateTime(2021, 7, 1)),
    new(3, "Carol Williams","Engineering",105000, new DateTime(2019, 11, 20))
];

// Build a DataTable from the list
DataTable dataTable = new();
dataTable.Columns.Add("Id",         typeof(int));
dataTable.Columns.Add("Name",       typeof(string));
dataTable.Columns.Add("Department", typeof(string));
dataTable.Columns.Add("Salary",     typeof(decimal));
dataTable.Columns.Add("HireDate",   typeof(DateTime));

foreach (var emp in employees)
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate);

// Create an IronXL workbook and worksheet
WorkBook workbook  = new();
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

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

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

// Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx");
Console.WriteLine("EmployeeReport.xlsx saved.");

Imports IronXL
Imports System.Data

' Define the Employee model
Public Class Employee
    Public Property Id As Integer
    Public Property Name As String
    Public Property Department As String
    Public Property Salary As Decimal
    Public Property HireDate As DateTime

    Public Sub New(id As Integer, name As String, department As String, salary As Decimal, hireDate As DateTime)
        Me.Id = id
        Me.Name = name
        Me.Department = department
        Me.Salary = salary
        Me.HireDate = hireDate
    End Sub
End Class

' Create sample employee data
Dim employees As New List(Of Employee) From {
    New Employee(1, "Alice Johnson", "Engineering", 95000D, New DateTime(2020, 3, 15)),
    New Employee(2, "Bob Smith", "Marketing", 75000D, New DateTime(2021, 7, 1)),
    New Employee(3, "Carol Williams", "Engineering", 105000D, New DateTime(2019, 11, 20))
}

' Build a DataTable from the list
Dim dataTable As New DataTable()
dataTable.Columns.Add("Id", GetType(Integer))
dataTable.Columns.Add("Name", GetType(String))
dataTable.Columns.Add("Department", GetType(String))
dataTable.Columns.Add("Salary", GetType(Decimal))
dataTable.Columns.Add("HireDate", GetType(DateTime))

For Each emp In employees
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate)
Next

' Create an IronXL workbook and worksheet
Dim workbook As New WorkBook()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

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

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

' Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx")
Console.WriteLine("EmployeeReport.xlsx saved.")

Ten przykład konwertuje List<Employee> na DataTable, a następnie zapisuje nagłówki i wiersze w arkuszu IronXL. IronXL automatycznie obsługuje typy danych, takie jak int, string i DateTime, zapewniając czyste formatowanie w wygenerowanym arkuszu kalkulacyjnym. Funkcja zapisywania w Excelu tworzy plik XLSX, który można otworzyć w dowolnym programie do obsługi arkuszy kalkulacyjnych.

Jak eksportować złożone obiekty biznesowe?

W rzeczywistych aplikacjach .NET często występują bardziej złożone struktury danych. Poniższy przykład generuje raport dotyczący zapasów produktów z wykorzystaniem właściwości obliczeniowej:

using IronXL;
using System.Data;

// Define the Product model with a computed property
record Product(
    string SKU,
    string ProductName,
    string Category,
    decimal Price,
    int StockLevel,
    bool IsActive,
    DateTime LastRestocked)
{
    public decimal CalculatedValue => Price * StockLevel;
}

// Build the product list
List<Product> products =
[
    new("TECH-001", "Wireless Mouse",      "Electronics",     29.99m, 150, true,  DateTime.Now.AddDays(-5)),
    new("TECH-002", "Mechanical Keyboard", "Electronics",     89.99m,  75, true,  DateTime.Now.AddDays(-12)),
    new("OFF-001",  "Desk Organizer",      "Office Supplies", 15.99m,   0, false, DateTime.Now.AddMonths(-1))
];

// Populate a DataTable
DataTable dt = new();
dt.Columns.Add("SKU",             typeof(string));
dt.Columns.Add("ProductName",     typeof(string));
dt.Columns.Add("Category",        typeof(string));
dt.Columns.Add("Price",           typeof(decimal));
dt.Columns.Add("StockLevel",      typeof(int));
dt.Columns.Add("IsActive",        typeof(bool));
dt.Columns.Add("LastRestocked",   typeof(DateTime));
dt.Columns.Add("CalculatedValue", typeof(decimal));

foreach (var p in products)
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price,
                p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue);

// Create the workbook
WorkBook  wb = WorkBook.Create();
WorkSheet ws = wb.CreateWorkSheet("Inventory");

// Write column headers
string[] headers = ["SKU","ProductName","Category","Price",
                    "StockLevel","IsActive","LastRestocked","CalculatedValue"];
for (int col = 0; col < headers.Length; col++)
    ws.SetCellValue(0, col, headers[col]);

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
    for (int col = 0; col < dt.Columns.Count; col++)
        ws.SetCellValue(row + 1, col, dt.Rows[row][col]);

// Auto-size columns for readability
for (int col = 0; col < headers.Length; col++)
    ws.AutoSizeColumn(col);

wb.SaveAs("ProductInventory.xlsx");
Console.WriteLine("ProductInventory.xlsx saved.");

using IronXL;
using System.Data;

// Define the Product model with a computed property
record Product(
    string SKU,
    string ProductName,
    string Category,
    decimal Price,
    int StockLevel,
    bool IsActive,
    DateTime LastRestocked)
{
    public decimal CalculatedValue => Price * StockLevel;
}

// Build the product list
List<Product> products =
[
    new("TECH-001", "Wireless Mouse",      "Electronics",     29.99m, 150, true,  DateTime.Now.AddDays(-5)),
    new("TECH-002", "Mechanical Keyboard", "Electronics",     89.99m,  75, true,  DateTime.Now.AddDays(-12)),
    new("OFF-001",  "Desk Organizer",      "Office Supplies", 15.99m,   0, false, DateTime.Now.AddMonths(-1))
];

// Populate a DataTable
DataTable dt = new();
dt.Columns.Add("SKU",             typeof(string));
dt.Columns.Add("ProductName",     typeof(string));
dt.Columns.Add("Category",        typeof(string));
dt.Columns.Add("Price",           typeof(decimal));
dt.Columns.Add("StockLevel",      typeof(int));
dt.Columns.Add("IsActive",        typeof(bool));
dt.Columns.Add("LastRestocked",   typeof(DateTime));
dt.Columns.Add("CalculatedValue", typeof(decimal));

foreach (var p in products)
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price,
                p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue);

// Create the workbook
WorkBook  wb = WorkBook.Create();
WorkSheet ws = wb.CreateWorkSheet("Inventory");

// Write column headers
string[] headers = ["SKU","ProductName","Category","Price",
                    "StockLevel","IsActive","LastRestocked","CalculatedValue"];
for (int col = 0; col < headers.Length; col++)
    ws.SetCellValue(0, col, headers[col]);

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
    for (int col = 0; col < dt.Columns.Count; col++)
        ws.SetCellValue(row + 1, col, dt.Rows[row][col]);

// Auto-size columns for readability
for (int col = 0; col < headers.Length; col++)
    ws.AutoSizeColumn(col);

wb.SaveAs("ProductInventory.xlsx");
Console.WriteLine("ProductInventory.xlsx saved.");

Imports IronXL
Imports System.Data

' Define the Product model with a computed property
Public Class Product
    Public Property SKU As String
    Public Property ProductName As String
    Public Property Category As String
    Public Property Price As Decimal
    Public Property StockLevel As Integer
    Public Property IsActive As Boolean
    Public Property LastRestocked As DateTime

    Public ReadOnly Property CalculatedValue As Decimal
        Get
            Return Price * StockLevel
        End Get
    End Property

    Public Sub New(sku As String, productName As String, category As String, price As Decimal, stockLevel As Integer, isActive As Boolean, lastRestocked As DateTime)
        Me.SKU = sku
        Me.ProductName = productName
        Me.Category = category
        Me.Price = price
        Me.StockLevel = stockLevel
        Me.IsActive = isActive
        Me.LastRestocked = lastRestocked
    End Sub
End Class

' Build the product list
Dim products As New List(Of Product) From {
    New Product("TECH-001", "Wireless Mouse", "Electronics", 29.99D, 150, True, DateTime.Now.AddDays(-5)),
    New Product("TECH-002", "Mechanical Keyboard", "Electronics", 89.99D, 75, True, DateTime.Now.AddDays(-12)),
    New Product("OFF-001", "Desk Organizer", "Office Supplies", 15.99D, 0, False, DateTime.Now.AddMonths(-1))
}

' Populate a DataTable
Dim dt As New DataTable()
dt.Columns.Add("SKU", GetType(String))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("StockLevel", GetType(Integer))
dt.Columns.Add("IsActive", GetType(Boolean))
dt.Columns.Add("LastRestocked", GetType(DateTime))
dt.Columns.Add("CalculatedValue", GetType(Decimal))

For Each p In products
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price, p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue)
Next

' Create the workbook
Dim wb As WorkBook = WorkBook.Create()
Dim ws As WorkSheet = wb.CreateWorkSheet("Inventory")

' Write column headers
Dim headers As String() = {"SKU", "ProductName", "Category", "Price", "StockLevel", "IsActive", "LastRestocked", "CalculatedValue"}
For col As Integer = 0 To headers.Length - 1
    ws.SetCellValue(0, col, headers(col))
Next

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

' Auto-size columns for readability
For col As Integer = 0 To headers.Length - 1
    ws.AutoSizeColumn(col)
Next

wb.SaveAs("ProductInventory.xlsx")
Console.WriteLine("ProductInventory.xlsx saved.")

Ten kod tworzy listę obiektów Product zawierających szczegóły takie jak SKU, cena, poziom zapasów i data ponownego zatowarowania, a następnie oblicza pochodną CalculatedValue dla każdego elementu. IronXL obsługuje typy danych, takie jak liczby dziesiętne, wartości logiczne i daty, zapewniając profesjonalny wygląd arkusza kalkulacyjnego. Rezultat, ProductInventory.xlsx, zapewnia czysty, oparty na danych eksport inwentaryzacji odpowiedni do raportowania biznesowego lub analizy. Możesz również eksportować DataTable do Excela bezpośrednio, jeśli twój istniejący kod bazowy już działa z obiektami DataTable.

Jak dodać profesjonalne formatowanie?

Formatowanie przekształca podstawowe eksporty w dopracowane raporty. API stylizacji IronXL udostępnia ustawienia czcionki, koloru, obramowania i formatu liczb dla dowolnej komórki lub zakresu:

using IronXL;

WorkBook  wb = WorkBook.Load("ProductInventory.xlsx");
WorkSheet ws = wb.DefaultWorkSheet;

// Bold header row with a blue background and white text
Range headerRange = ws["A1:H1"];
headerRange.Style.Font.Bold            = true;
headerRange.Style.BackgroundColor      = "#4472C4";
headerRange.Style.Font.Color           = "#FFFFFF";

// Format the Price column as currency
Range priceColumn = ws["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";

// Highlight low-stock rows in red
for (int row = 2; row <= 4; row++)
{
    var stockCell = ws[$"E{row}"];
    if (stockCell.IntValue < 10)
        stockCell.Style.BackgroundColor = "#FF6B6B";
}

wb.SaveAs("FormattedInventory.xlsx");
Console.WriteLine("FormattedInventory.xlsx saved.");

using IronXL;

WorkBook  wb = WorkBook.Load("ProductInventory.xlsx");
WorkSheet ws = wb.DefaultWorkSheet;

// Bold header row with a blue background and white text
Range headerRange = ws["A1:H1"];
headerRange.Style.Font.Bold            = true;
headerRange.Style.BackgroundColor      = "#4472C4";
headerRange.Style.Font.Color           = "#FFFFFF";

// Format the Price column as currency
Range priceColumn = ws["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";

// Highlight low-stock rows in red
for (int row = 2; row <= 4; row++)
{
    var stockCell = ws[$"E{row}"];
    if (stockCell.IntValue < 10)
        stockCell.Style.BackgroundColor = "#FF6B6B";
}

wb.SaveAs("FormattedInventory.xlsx");
Console.WriteLine("FormattedInventory.xlsx saved.");

Imports IronXL

Dim wb As WorkBook = WorkBook.Load("ProductInventory.xlsx")
Dim ws As WorkSheet = wb.DefaultWorkSheet

' Bold header row with a blue background and white text
Dim headerRange As Range = ws("A1:H1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.Color = "#FFFFFF"

' Format the Price column as currency
Dim priceColumn As Range = ws("D2:D100")
priceColumn.Style.NumberFormat = "$#,##0.00"

' Highlight low-stock rows in red
For row As Integer = 2 To 4
    Dim stockCell = ws($"E{row}")
    If stockCell.IntValue < 10 Then
        stockCell.Style.BackgroundColor = "#FF6B6B"
    End If
Next

wb.SaveAs("FormattedInventory.xlsx")
Console.WriteLine("FormattedInventory.xlsx saved.")

Te opcje stylizacji przekształcają surowe dane eksportowane w raporty gotowe do przedstawienia kierownictwu. Pogrubione nagłówki z kolorowym tłem tworzą wizualną hierarchię. Formatowanie liczb zapewnia prawidłowe wyświetlanie wartości walutowych. Formatowanie warunkowe wyróżnia kluczowe wskaźniki biznesowe, takie jak niskie poziomy zapasów, dzięki czemu wyeksportowany arkusz kalkulacyjny Excel można natychmiast wykorzystać do zarządzania zapasami. Możesz dowiedzieć się więcej o zaawansowanym formatowaniu komórek i stylach obramowań, aby jeszcze bardziej ulepszyć eksport.

Jak eksportować listy do innych formatów plików?

IronXL nie ogranicza się do formatu XLSX. Ten sam obiekt WorkBook może być zapisany do kilku formatów przy jednej zmianie metody:

• XLSX -- Domyślny nowoczesny format Excela: workbook.SaveAs("output.xlsx")
• XLS — starszy format Excel dla starszych wersji pakietu Office
• CSV — wartości rozdzielone przecinkami zapewniające kompatybilność z potokami danych
• TSV — wartości rozdzielone tabulatorami

Podczas eksportu do formatu CSV każdy arkusz staje się oddzielnym plikiem CSV. Dzięki temu IronXL jest przydatny nie tylko do tworzenia raportów dla użytkowników końcowych, ale także do generowania pośrednich plików danych wykorzystywanych przez potoki ETL, narzędzia do analizy danych lub interfejsy API innych firm. W przypadku eksportu danych DataGridView — powszechnego wzorca w aplikacjach Windows Forms — IronXL integruje się płynnie bez konieczności stosowania dodatkowych adapterów.

Jak wyeksportować listy do Excela w ASP.NET Core?

Podczas tworzenia interfejsów API lub aplikacji Razor Pages zazwyczaj chcesz zwrócić plik Excel jako odpowiedź HTTP, zamiast zapisywać go na dysku. Poniższy wzorzec zwraca FileContentResult z akcji kontrolera:

Kontroler wstrzykuje usługę, która buduje WorkBook, wywołuje workbook.ToByteArray(), a następnie zwraca bajty z typem MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet i nagłówkiem Content-Disposition: attachment. To podejście działa w każdym minimalnym API .NET 10 lub kontrolerze MVC.

Aby uzyskać kompletny przewodnik, zapoznaj się z samouczkiem dotyczącym eksportu do programu Excel w ASP.NET Core oraz samouczkiem dotyczącym eksportu w Blazor, jeśli tworzysz aplikację Blazor WebAssembly lub Blazor Server.

Jak już dziś rozpocząć pracę z IronXL?

IronXL przekształca zadanie generowania plików Excel w łatwy w utrzymaniu kod. Jego API eliminuje zależności od pakietu Microsoft Office, zapewniając jednocześnie profesjonalne wyniki spełniające wymagania Enterprise. Zestaw funkcji biblioteki obsługuje wszystko, od podstawowego eksportu list po złożone transformacje danych z zastosowaniem stylizacji i formatowania.

Można również używać IronXL do odczytu i edycji istniejących skoroszytów, eksportowania danych z Excela do DataTable w celu dalszego przetwarzania lub tworzenia tabel przestawnych do raportowania podsumowującego. Połącz dowolną z tych funkcji z opcjami formatowania pokazanymi powyżej, aby tworzyć arkusze kalkulacyjne, które nie wymagają ręcznych poprawek przed dystrybucją.

IronXL jest dostępny w serwisie NuGet i działa z każdym projektem przeznaczonym dla platform .NET 10, .NET 8 lub .NET Framework 4.6.2+. Open XML SDK stanowi podstawę formatu plików XLSX, który IronXL odczytuje i zapisuje, dając pewność, że wygenerowane pliki są zgodne ze standardem ECMA-376 i otwierają się poprawnie w każdej aplikacji zgodnej z OOXML.

Zacznij z IronXL teraz.

Zacznij za darmo

Gotowy, aby rozpocząć eksportowanie list C# do Excela? Pobierz IronXL już teraz i przekonaj się, jak szybko możesz konwertować obiekty listy do formatu Excel w swoich aplikacjach .NET. W przypadku wdrożeń produkcyjnych zapoznaj się z elastycznymi opcjami licencyjnymi, które można skalować zgodnie z Twoimi potrzebami. Więcej samouczków i przykładów znajdziesz w dokumentacji.