Jak wyeksportować listę obiektów do programu Excel w języku C#

Dlaczego eksportowanie list do plików Excel stanowi wyzwanie?

Tradycyjne podejścia do eksportowania danych do Excela często obejmują Microsoft Office Interop, który wymaga zainstalowania Excela na serwerze i powoduje problemy z wdrażaniem. Ręczne wypełnianie komórek za pomocą refleksji jest czasochłonne i podatne na błędy. Potężne funkcje importu danych IronXL rozwiązują te problemy poprzez inteligentne mapowanie właściwości między źródłami danych a nagłówkami kolumn Excel, bez potrzeby MS Office czy złożonego kodu refleksji.

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 Excel w C# bez Interop, IronXL jest idealny dla nowoczesnych projektów .NET, które potrzebują solidnej generacji Excela i możliwości importu/eksportu danych. Biblioteka bezproblemowo integruje się z aplikacjami .NET MAUI i wspiera wdrożenia na platformach chmurowych Azure i AWS.

Pracując z dużymi zestawami danych, tradycyjne metody często zmagają się z zarządzaniem pamięcią i wydajnością. IronXL rozwiązuje te problemy dzięki zoptymalizowanym wewnętrznym strukturom danych, które skutecznie obsługują konwersję pomiędzy różnymi formatami arkuszy kalkulacyjnych, zachowując doskonałe charakterystyki wydajnościowe.

Jak eksportować proste dane listy do Excela?

Rozpoczęcie pracy z IronXL wymaga minimalnej konfiguracji. Najpierw zainstaluj bibliotekę przez konsolę Menedżera Pakietów NuGet:

Install-Package IronXL.Excel

Po zainstalowaniu można od razu zacząć tworzyć arkusze kalkulacyjne Excel z użyciem struktur danych C#. Przyjrzyjmy się, jak eksportować dane za pomocą modelu Employee:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        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 employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        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 employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

Imports IronXL
Imports System.Collections.Generic
Imports System.Data

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
End Class

Class Program
    Shared Sub Main(ByVal args As String())
        ' Create sample data for Excel export
        Dim employees As New List(Of Employee) From {
            New Employee With {.Id = 1, .Name = "Alice Johnson", .Department = "Engineering", .Salary = 95000, .HireDate = New DateTime(2020, 3, 15)},
            New Employee With {.Id = 2, .Name = "Bob Smith", .Department = "Marketing", .Salary = 75000, .HireDate = New DateTime(2021, 7, 1)},
            New Employee With {.Id = 3, .Name = "Carol Williams", .Department = "Engineering", .Salary = 105000, .HireDate = New DateTime(2019, 11, 20)}
        }

        ' Convert the list of employees to a DataTable
        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 employee In employees
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate)
        Next

        ' Export DataTable to Excel spreadsheet
        Dim workbook As New WorkBook()
        Dim worksheet = workbook.CreateWorkSheet("Employees")

        ' Populate the worksheet
        For i As Integer = 0 To dataTable.Columns.Count - 1
            worksheet.SetCellValue(0, i, dataTable.Columns(i).ColumnName) ' Add column headers
        Next

        For i As Integer = 0 To dataTable.Rows.Count - 1
            For j As Integer = 0 To dataTable.Columns.Count - 1
                worksheet.SetCellValue(i + 1, j, dataTable.Rows(i)(j)) ' Add data rows
            Next
        Next

        ' Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx")
    End Sub
End Class

Ten przykładowy kod pokazuje, jak eksportować dane do Excela z List<Employee> używając IronXL. Najpierw konwertuje listę pracowników na DataTable, a następnie ręcznie zapisuje nagłówki kolumn i wiersze w arkuszu. IronXL automatycznie obsługuje typy danych, takie jak int, string i DateTime, zapewniając czyste formatowanie w generowanym arkuszu kalkulacyjnym. Na koniec funkcja zapisu Excela tworzy plik XLSX zapisany jako EmployeeReport.xlsx, oferując prosty i efektywny sposób przekształcenia ustrukturyzowanych danych C# w profesjonalny raport Excel.

Podejście przedstawione powyżej reprezentuje bazowy wzorzec, który można rozszerzyć dla bardziej złożonych scenariuszy. Na przykład, możesz potrzebować eksportować zestawy danych i tabele datowe z istniejących zapytań bazodanowych lub importować dane z Excela z zewnętrznych źródeł. IronXL zapewnia kompleksowe metody dla obu scenariuszy, czyniąc go wszechstronnym narzędziem do operacji wymiany danych.

Jak eksportować złożone obiekty biznesowe?

W rzeczywistych aplikacjach .NET często występują bardziej złożone struktury danych. Pracując z właściwościami zagnieżdżonymi, polami obliczonymi lub danymi hierarchicznymi, potrzebujesz bardziej zaawansowanego podejścia. IronXL doskonale radzi sobie z obsługą tych scenariuszy, zapewniając solidne wsparcie dla pracy z danymi w różnych formatach. Oto jak eksportować inwentaryzację produktów z zagnieżdżonymi właściwościami:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

Imports IronXL
Imports System.Collections.Generic
Imports System.Data

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
End Class

Class Program
    Shared Sub Main(args As String())
        ' Generate product inventory list for Excel export
        Dim products As New List(Of Product) From {
            New Product With {
                .SKU = "TECH-001",
                .ProductName = "Wireless Mouse",
                .Category = "Electronics",
                .Price = 29.99D,
                .StockLevel = 150,
                .IsActive = True,
                .LastRestocked = DateTime.Now.AddDays(-5)
            },
            New Product With {
                .SKU = "TECH-002",
                .ProductName = "Mechanical Keyboard",
                .Category = "Electronics",
                .Price = 89.99D,
                .StockLevel = 75,
                .IsActive = True,
                .LastRestocked = DateTime.Now.AddDays(-12)
            },
            New Product With {
                .SKU = "OFF-001",
                .ProductName = "Desk Organizer",
                .Category = "Office Supplies",
                .Price = 15.99D,
                .StockLevel = 0,
                .IsActive = False,
                .LastRestocked = DateTime.Now.AddMonths(-1)
            }
        }
        ' Create Excel workbook and import collection data
        Dim workbook = WorkBook.Create()
        Dim worksheet = workbook.CreateWorkSheet("Inventory")
        ' Export generic list to Excel with headers
        Dim dataTable As New DataTable()
        dataTable.Columns.Add("SKU", GetType(String))
        dataTable.Columns.Add("ProductName", GetType(String))
        dataTable.Columns.Add("Category", GetType(String))
        dataTable.Columns.Add("Price", GetType(Decimal))
        dataTable.Columns.Add("StockLevel", GetType(Integer))
        dataTable.Columns.Add("IsActive", GetType(Boolean))
        dataTable.Columns.Add("LastRestocked", GetType(DateTime))
        dataTable.Columns.Add("CalculatedValue", GetType(Decimal))
        For Each product In products
            dataTable.Rows.Add(product.SKU, product.ProductName, product.Category, product.Price, product.StockLevel, product.IsActive, product.LastRestocked, product.CalculatedValue)
        Next
        ' With the following code:
        worksheet("A1").Value = "SKU"
        worksheet("B1").Value = "ProductName"
        worksheet("C1").Value = "Category"
        worksheet("D1").Value = "Price"
        worksheet("E1").Value = "StockLevel"
        worksheet("F1").Value = "IsActive"
        worksheet("G1").Value = "LastRestocked"
        worksheet("H1").Value = "CalculatedValue"
        Dim row As Integer = 2
        For Each dataRow As DataRow In dataTable.Rows
            worksheet($"A{row}").Value = dataRow("SKU")
            worksheet($"B{row}").Value = dataRow("ProductName")
            worksheet($"C{row}").Value = dataRow("Category")
            worksheet($"D{row}").Value = dataRow("Price")
            worksheet($"E{row}").Value = dataRow("StockLevel")
            worksheet($"F{row}").Value = dataRow("IsActive")
            worksheet($"G{row}").Value = dataRow("LastRestocked")
            worksheet($"H{row}").Value = dataRow("CalculatedValue")
            row += 1
        Next
        ' Auto-fit columns for optimal display
        For col As Integer = 0 To 7
            worksheet.AutoSizeColumn(col)
        Next
        ' Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx")
    End Sub
End Class

Ten kod demonstruje, jak wygenerować dynamiczny raport inwentaryzacyjny produktu w Excelu przy użyciu IronXL. Tworzy listę obiektów Product zawierających szczegóły takie jak SKU, cena, poziom zapasów i data uzupełnienia zapasów, po czym oblicza pochodną CalculatedValue dla każdego przedmiotu. Dane są konwertowane na DataTable, zapisywane w arkuszu Excel z nagłówkami i formatowane dla czytelności przy użyciu automatycznie rozmiarowych kolumn. IronXL bezproblemowo obsługuje typy danych, takie jak dziesiętne, booleany i daty, zapewniając profesjonalne wyjście z arkusza kalkulacyjnego. Rezultat, ProductInventory.xlsx, zapewnia czysty, oparty na danych eksport inwentarza idealny do raportowania biznesowego lub analizy.

Pracując z złożonymi obiektami, możesz także potrzebować zarządzać arkuszami roboczymi dla różnych kategorii danych lub tworzyć wiele arkuszy w jednym skoroszycie. IronXL wspiera zaawansowane operacje na arkuszach roboczych, pozwalając organizować eksportowane dane logicznie. Dodatkowo, możesz wybierać określone zakresy do ukierunkowanych operacji na danych lub sortować komórki w celu przedstawienia danych w znaczącej kolejności.

Jak dodać profesjonalne formatowanie?

Przekształć podstawowe eksporty w wykończone raporty dzięki kompleksowym możliwościom stylistycznym IronXL. Profesjonalne formatowanie podnosi eksporty z Excela z prostych zrzutów danych do gotowych do prezentacji raportów, które efektywnie przekazują wnioski. IronXL zapewnia rozległe opcje formatowania, w tym dostosowanie czcionki i rozmiaru komórek, wzory tła i kolory oraz ustawienia obramowania i wyrównania:

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

Te opcje stylizacji przekształcają surowe dane eksportowane w raporty gotowe do przedstawienia kierownictwu. Pogrubione nagłówki z kolorami tła tworzą wizualną hierarchię podczas eksportowania kolekcji do Excela. Formatowanie liczb zapewnia profesjonalne wyświetlanie wartości walutowych. Warunkowe formatowanie podkreśla kluczowe metryki biznesowe, takie jak niskie poziomy zapasów, czyniąc wyeksportowany arkusz Excel od razu użytecznym dla zarządzania inwentaryzacją. Dowiedz się więcej o zaawansowanym formatowaniu komórek i stylach obramowania, aby jeszcze bardziej udoskonalić swoje eksporty.

Poza podstawowym formatowaniem, IronXL wspiera zaawansowane funkcje, takie jak tworzenie wykresów Excel do wizualizacji eksportowanych danych. Możesz także dodawać hiperłącza do łączenia powiązanych punktów danych lub zasobów zewnętrznych, zamrażać okienka dla lepszej nawigacji po dużych zbiorach danych, a nawet scalać komórki do tworzenia wyrafinowanych układów raportów.

Jaki jest najlepszy sposób na rozpoczęcie z IronXL?

IronXL przekształca złożone zadanie generowania Excel w proste, łatwe do utrzymania kod. Inteligentna metoda ImportData eliminuje potrzebę zależności od Microsoft Office, zapewniając jednocześnie profesjonalne wyniki spełniające wymagania przedsiębiorstw. Kompleksowy zestaw funkcji biblioteki obsługuje wszystko, od podstawowego eksportu list po złożone transformacje danych z zastosowaniem stylizacji i formatowania.

Rozpoczęcie pracy z IronXL jest proste. Biblioteka obsługuje różne scenariusze wdrażania, w tym kontenery Docker, środowiska Linux i systemy macOS. W przypadku wdrożeń korporacyjnych IronXL oferuje kompleksowe opcje licencyjne z elastycznym Zarządzaniem kluczami licencyjnymi.

Biblioteka doskonale sprawdza się również w operacjach wymiany danych. Możesz konwertować pliki XLSX do formatu CSV, zapisywać pliki CSV, odczytywać dane CSV, a nawet konwertować tabele danych (DataTables) do formatu CSV. W przypadku aplikacji internetowych IronXL płynnie integruje się z frameworkami ASP.NET MVC i Blazor.

Podczas pracy z istniejącymi plikami Excel IronXL zapewnia zaawansowane funkcje do edycji plików Excel, otwierania arkuszy i odczytu plików XLSX. Możesz również pracować z plikami Excel w VB.NET, jeśli Twój projekt wymaga integracji z Visual Basic.

Zacznij z IronXL teraz.

Zacznij za darmo

Chcesz usprawnić eksport danych z Excel do C#? Pobierz IronXL już teraz, aby skalować rozwiązanie zgodnie z Twoimi potrzebami. Odwiedź naszą obszerną dokumentację, aby uzyskać więcej samouczków i przykładów. Zapoznaj się z dokumentacją API, aby uzyskać szczegółowe specyfikacje techniczne i dowiedzieć się, jak IronXL może zmienić Twoje procesy automatyzacji w Excelu.