Ikona wiadomości
Przejdź do treści stopki
  1. IronXL
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. C# Export List Object to Excel
KORZYSTANIE Z IRONXL

C# Eksportuj obiekt listy do Excel

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Eksportowanie zbiorów obiektów do plików Excel jest podstawowym wymogiem w aplikacjach biznesowych. Niezależnie od tego, czy chodzi o generowanie raportów, udostępnianie analiz danych czy tworzenie arkuszy Excel na potrzeby kopii zapasowych, programiści potrzebują niezawodnego sposobu na przekształcanie obiektów List<t> w profesjonalne arkusze kalkulacyjne. IronXL oferuje rozwiązanie, które eliminuje tradycyjne trudności związane z tworzeniem plików Excel w .NET 10, .NET Core lub .NET Framework — bez konieczności instalowania pakietu Microsoft Office na serwerze.

Dłączego 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 skomplikówanego 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.

W jaki sposób IronXL upraszcza eksport obiektów?

IronXL eliminuje konieczność rejestracji COM, licencji Office i zestawów interoperacyjnych. Po wyeksportowaniu List<t> do programu Excel biblioteka:

  • Mapuje właściwości obiektów bezpośrednio na nagłówki kolumn
  • Konwertuje typy .NET (DateTime, decimal, bool) na ich poprawne reprezentacje w Excelu
  • Umożliwia precyzyjną kontrolę nad wartościami komórek, zakresami i formatowaniem
  • Zapisuje wyniki w formatach XLSX, XLS, CSV i innych za pomocą jednego wywołania metody

Takie podejście pozwala uzyskać przejrzysty, profesjonalny arkusz kalkulacyjny bez konieczności pisania setek linii standardowego kodu. Można również później zaimportować dane z powrotem z Excela, co sprawia, że przepływ danych w obie strony jest prosty.

Jak zainstalować IronXL?

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

Install-Package IronXL
Install-Package IronXL
SHELL

Lub użyj interfejsu CLI platformy .NET:

dotnet add package IronXL
dotnet add package IronXL
SHELL

Po zainstalowaniu dodaj dyrektywę using IronXL; do swojego pliku. Nie są wymagańe żadne dodatkowe zależności Office ani instalacje środowiska uruchomieniowego.

Jak wyeksportować prostą listę do programu Excel?

Poniższy przykład ilustruje eksportowanie listy obiektów Employee do pliku XLSX przy użyciu instrukcji najwyższego poziomu, co jest preferowanym stylem 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.")
$vbLabelText   $csharpLabel

W tym przykładzie List<Employee> jest konwertowane na DataTable, a następnie nagłówki i wiersze są zapisywane w arkuszu IronXL. IronXL automatycznie obsługuje typy danych, takie jak int, string i DateTime, zapewniając przejrzyste 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.

C# Eksport listy obiektów do Excela za pomocą IronXL: Obraz 1 - Obraz 1 z 3 związanych z C# Eksport listy obiektów do Excela za pomocą IronXL

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.")
$vbLabelText   $csharpLabel

Ten kod tworzy listę obiektów Product zawierających szczegóły, takie jak SKU, cena, stan magazynowy i data uzupełnienia zapasów, a następnie oblicza pochodną CalculatedValue dla każdej pozycji. IronXL obsługuje typy danych, takie jak liczby dziesiętne, wartości logiczne i daty, zapewniając profesjonalny wygląd arkusza kalkulacyjnego. Wynik, ProductInventory.xlsx, zapewnia przejrzysty, oparty na danych eksport zapasów, odpowiedni do raportowania biznesowego lub analiz. Możesz również wyeksportować tabelę danych (DataTable) bezpośrednio do programu Excel, jeśli Twój istniejący kod źródłowy już obsługuje obiekty DataTable.

C# Eksport listy obiektów do Excela za pomocą IronXL: Obraz 2 – Przykładowy wynik dla złożonych obiektów biznesowych

Jak kontrolować szerokość kolumn i wysokość wierszy?

Po zapisaniu danych można programowo kontrolować układ wizualny arkusza kalkulacyjnego. Metoda AutoSizeColumn w IronXL dostosowuje każdą kolumnę do zawartości. Alternatywnie można ustawić konkretne szerokości kolumn lub dodawać i usuwać wiersze oraz kolumny, aby dostosować strukturę arkusza przed zapisaniem.

W przypadku wysokości wiersza IronXL udostępnia właściwości na poziomie wiersza, które pozwalają ustawić stałą wysokość w pikselach — przydatne, gdy arkusz zostanie wydrukowany lub udostępniony jako plik PDF. Spójne rozmiary kolumn i wierszy poprawiają również czytelność, gdy plik Excel jest otwierany na ekranach o różnych rozdzielczościach lub drukowany w różnych skalach, co jest szczególnie ważne w przypadku raportów przekazywanych zewnętrznym interesariuszom.

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.")
$vbLabelText   $csharpLabel

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 warunkówe 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.

C# Eksport listy obiektów do Excela za pomocą IronXL: Obraz 3 – Sformatowany arkusz

Jak programowo zastosować formatowanie warunkówe?

IronXL obsługuje reguły formatowania warunkówego, które odzwierciedlają wbudowaną funkcję programu Excel. Można zdefiniować reguły oparte na progach wartości komórek, dopasowaniu tekstu lub zakresach dat. Po zastosowaniu reguły do zakresu IronXL zapisuje odpowiednie metadane w formacie XLSX, dzięki czemu plik zachowuje się dokładnie tak, jak oczekiwano, po otwarciu w programie Excel lub Arkuszach Google.

Jest to szczególnie przydatne, gdy eksportowany plik będzie przeglądany przez osoby nieposiadające wiedzy technicznej, które oczekują raportów oznaczonych kolorami, a nie zwykłych danych tabelarycznych.

Jak sortować i filtrować dane przed eksportem?

Możesz sortować i filtrować swoje List<t> przed zapisaniem ich w Excelu. Korzystając ze standardowego LINQ, można posortować pracowników według działu i wynagrodzenia lub filtrować produkty, wyświetlając tylko te aktywne. Gdy filtrowana lista będzie gotowa, zapisz ją w arkuszu, stosując to samo podejście kolumna po kolumnie, co powyżej.

IronXL obsługuje również sortowanie komórek w już wypełnionym zakresie bezpośrednio w skoroszycie — umożliwiając sortowanie po wypełnieniu bez konieczności powrotu do oryginalnego zbioru.

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

IronXL nie ogranicza się do formatu XLSX. Ten sam obiekt WorkBook można zapisać w kilku formatach za pomocą jednej zmiany metody:

  • XLSX — domyślny nowoczesny format programu Excel: 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 efektywnie radzić sobie z dużymi zbiorami danych?

Podczas eksportowania tysięcy wierszy wydajność staje się istotnym czynnikiem. Należy pamiętać o następujących wytycznych:

  • Najpierw wypełnij DataTable i zapisz wiersze w pętli, zamiast wielokrotnie wywoływać poszczególne metody ustawiające komórki z poziomu refleksji.
  • Wywołaj AutoSizeColumn dopiero po zapisaniu wszystkich danych, ponieważ jest to operacja odczytu i skanowania.
  • Unikaj otwierania skoroszytu w celu ponownego odczytu i ponownego zapisywania w ciasnej pętli — zbuduj kompletny zbiór danych w pamięci, a następnie wywołaj SaveAs jeden raz.
  • W przypadku zbiorów danych zawierających ponad 100 000 wierszy warto rozważyć podzielenie eksportu na wiele arkuszy, aby zachować limity liczby wierszy w programie Excel i utrzymać rozsądny rozmiar plików.

IronXL zapewnia również proces eksportu .NET Core, w którym plik XLSX jest zapisywany bezpośrednio do MemoryStream i zwracany jako odpowiedź w postaci pliku do pobrania, całkowicie omijając operacje wejścia/wyjścia na dysku.

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

!{--01001100010010010100001001010010010000010101001001011001010111110100011101000101010101000101111101010011010101000100000101010010010101000100010101000100010111110101011101001001010100010010000101111101010000010100100100111101000100010101010100001101010100010111110101010001010010010010010100000101001100010111110100001001001100010011110100001101001011--}

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.

Często Zadawane Pytania

Jak mogę eksportować listę C# do pliku Excel?

Możesz eksportować listę C# do pliku Excel, używając metody ImportData IronXL, który upraszcza proces bez potrzeby korzystania z Office Interop.

Dlaczego powinienem używać IronXL do eksportu danych do Excel?

IronXL zapewnia usprawnione rozwiązanie do eksportu danych do Excel, eliminując tradycyjne złożoności i oferując łatwą integrację z .NET, .NET Core lub .NET Framework.

Czy do korzystania z IronXL muszę mieć zainstalowany pakiet Microsoft Office?

Nie, IronXL nie wymaga zainstalowanego Microsoft Office. Działa niezależnie, pozwalając na tworzenie i manipulowanie plikami Excel programowo.

Czy IronXL może obsługiwać złożone obiekty w listach przy eksporcie do Excela?

Tak, IronXL może obsługiwać zarówno listy generyczne, jak i złożone obiekty, zapewniając elastyczność w eksportowaniu różnych typów danych do Excel.

Czy IronXL jest kompatybilny z .NET Core?

Tak, IronXL jest kompatybilny z .NET Core, a także z .NET i .NET Framework, co czyni go wszechstronnym dla różnych środowisk deweloperskich.

Jaka jest zaleta korzystania z metody ImportData IronXL?

Metoda ImportData w IronXL upraszcza proces przenoszenia danych z list C# do Excel, zmniejszając złożoność kodu i poprawiając produktywność.

Czy mogę tworzyć profesjonalne arkusze kalkulacyjne za pomocą IronXL?

Absolutnie, IronXL pozwala deweloperom łatwo przekształcić obiekty List w profesjonalne arkusze kalkulacyjne, odpowiednie do raportów, udostępniania danych czy tworzenia kopii zapasowych.

Czy dostępne są przykłady kodu dla użycia IronXL?

Tak, dokumentacja i samouczki IronXL dostarczają prostych przykładów kodu do eksportu zarówno list generycznych, jak i złożonych obiektów do Excel.

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