Twórz pliki Excel w języku C# za pomocą biblioteki IronXL, która umożliwia tworzenie, formatowanie i wypełnianie arkuszy kalkulacyjnych Excel bez pakietu Microsoft Office. Jest to idealne rozwiązanie dla środowisk serwerowych, kontenerów Docker oraz potoków CI/CD.
DevOps jest ważne?Opracowanie funkcji generowania plików Excel bez korzystania z pakietu Office pozwala sprostać kluczowym wyzwaniom związanym z wdrażaniem. W środowiskach serwerowych często brakuje pakietu Microsoft Office ze względu na koszty licencji i wymagania dotyczące zasobów. Każda instalacja pakietu Office wymaga znacznej ilości miejsca na dysku i pamięci, co sprawia, że nie nadaje się on do wdrożeń w chmurze ani aplikacji kontenerowych. Podczas wdrażania w AWS Lambda lub uruchamiania w kontenerach Docker lekkie rozwiązanie ma kluczowe znaczenie dla automatyzacji infrastruktury.
IronXL eliminuje te ograniczenia, działając niezależnie. Generowanie plików Excel działa bez zmian w systemach Windows, Linux, macOS, kontenerach Docker lub usługach Azure App Services. Ta kompatybilność między platformami oznacza, że piszesz kod raz i wdrażasz go gdziekolwiek, niezależnie od tego, czy tworzysz aplikacje dla .NET Framework, .NET Core czy .NET 8/9. Dla zespołów korzystających z .NET MAUI lub Blazor, IronXL płynnie integruje się ze wszystkimi nowoczesnymi platformami .NET.
IronXL obsługuje wszystkie główne platformy .NET i systemy operacyjne, zapewniając maksymalną elastyczność wdrożenia.
| Funkcja | IronXL | EPPlus | ClosedXML | NPOI |
|---|---|---|---|---|
| Cena | $999 | $599 | Bezpłatne | Bezpłatne |
| Zależność od pakietu Office | None | None | None | None |
| Wydajność | 40 razy szybsze* | Dobrze | Umiarkowany | Powolny |
| Wykorzystanie pamięci | <1GB** | 2–3 GB | 1–2 GB | 3–5 GB |
| Obsługa Docker | Język ojczysty | Ograniczone | Podstawowe | Podstawowe |
| Obsługa formuł | Ponad 165 funkcji | 100+ | 80+ | Podstawowe |
| Wsparcie komercyjne | Tak | Tak | Nie | Nie |
| Krzywa uczenia się | Łatwe | Umiarkowany | Umiarkowany | Strome |
*W oparciu o ostatnie ulepszenia wydajności **Do przetwarzania dużych plików Excel
Wydajność znacznie wzrasta bez obciążenia związanego z COM Interop. Tradycyjna automatyzacja biurowa tworzy oddzielne instancje procesów dla każdej operacji, zużywając pamięć i zasoby procesora. IronXL przetwarza wszystko w pamięci w przestrzeni procesowej aplikacji, co skutkuje szybszym działaniem i mniejszym zużyciem zasobów podczas programowego generowania plików Excel. Biblioteka przeszła znaczną optymalizację wydajności, a ostatnie aktualizacje zapewniły nawet 40-krotny wzrost szybkości działania oraz radykalne zmniejszenie zużycia pamięci z 19,5 GB do poniżej 1 GB.
Wdrożenie jest proste, ponieważ IronXL jest dostarczany jako pojedynczy pakiet NuGet. Nie ma żadnych wpisów w rejestrze, rejestracji COM ani dodatków Service Pack do pakietu Office, które trzeba by utrzymywać. Twoje potoki ciągłej integracji działają płynnie, a kontenery Docker pozostają lekkie. To uproszczone podejście sprawiło, że IronXL stał się popularnym wyborem, o czym dyskutuje się na różnych forach programistów, gdzie Professionals dzielą się swoimi doświadczeniami z automatyzacją Excela bez Interop.
IronXL zapewnia pełen zestaw funkcji do pracy z plikami Excel dzięki intuicyjnej konstrukcji API.
DevOps przepływów pracy?Instalacja IronXL zajmuje zaledwie kilka chwil za pomocą menedżera pakietów NuGet. W programie Visual Studio kliknij prawym przyciskiem myszy swój projekt i wybierz opcję "Zarządzaj pakietami NuGet". Wyszukaj "IronXL.Excel" i kliknij "Zainstaluj". Pakiet automatycznie zawiera wszystkie zależności wymagane do generowania plików Excel w języku C#. Szczegółowe wskazówki dotyczące instalacji dostosowane do Twojego środowiska programistycznego znajdziesz w przewodniku "Pierwsze kroki".
Alternatywnie można użyć konsoli menedżera pakietów:
Konsola menedżera pakietów potwierdza pomyślną instalację IronXL wraz ze wszystkimi wymaganymi zależnościami.
Dla użytkowników .NET CLI pracujących z nowoczesnymi projektami C# w zautomatyzowanych procesach kompilacji:
W przypadku wdrożeń kontenerowych dodaj do pliku Dockerfile:
RUN dotnet add package IronXL.ExcelSprawdź instalację za pomocą tego prostego testu, aby programowo tworzyć pliki Excel:
using IronXL;
// new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");Imports IronXL
' new Excel workbook
Dim workbook = WorkBook.Create()
Console.WriteLine("IronXL installed successfully!")Ten kod tworzy obiekt skoroszytu w pamięci. Jeśli program działa bez błędów, IronXL jest gotowy do użycia. Biblioteka obsługuje wszystkie nowoczesne wersje .NET, zapewniając kompatybilność z istniejącymi projektami. Dla programistów VB.NET dostępna jest podobna funkcjonalność wraz z przykładami składni specyficznymi dla VB. W przypadku pracy ze starszymi formatami plików lub problemów z rozmiarem plików biblioteka zapewnia kompletne rozwiązania.
Wynik wyświetlony w konsoli potwierdza, że IronXL jest poprawnie zainstalowany i gotowy do generowania plików Excel.
Tworzenie plików Excel za pomocą IronXL wymaga zaledwie kilku wierszy kodu, co sprawia, że jest to idealne rozwiązanie do szybkiego tworzenia i wdrażania aplikacji.
using IronXL;
// Create a new workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Add data
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Save the file
workbook.SaveAs("sales_report.xlsx");
Tworzenie plików Excel za pomocą IronXL zaczyna się od klasy WorkBook, będącej twoim punktem wyjścia do wszystkich operacji Excela. Biblioteka obsługuje zarówno nowoczesny format XLSX, jak i starszy format XLS, co zapewnia elastyczność w przypadku różnych wymagań podczas generowania plików Excel w języku C#. Funkcja tworzenia arkusza kalkulacyjnego zapewnia pełen zestaw opcji do inicjalizacji nowych skoroszytów.
using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");Imports IronXL
' Create a new workbook (XLSX format by default)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add metadata
workbook.Metadata.Title = "Monthly Sales Report"
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Comments = "Generated using IronXL"
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("January Sales")
' Add some basic data
worksheet("A1").Value = "Date"
worksheet("B1").Value = "Product"
worksheet("C1").Value = "Quantity"
worksheet("D1").Value = "Revenue"
' Add data rows
worksheet("A2").Value = New DateTime(2024, 1, 15)
worksheet("B2").Value = "Widget Pro"
worksheet("C2").Value = 100
worksheet("D2").Value = 2500.0
' Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx")Ten kod ilustruje kilka kluczowych koncepcji związanych z generowaniem plików Excel. Metoda WorkBook.Create() inicjuje nowy plik Excel w pamięci. Określasz format używając enum ExcelFileFormat - wybierz XLSX dla nowoczesnej kompatybilności Excela lub XLS dla wsparcia starszych wersji. Właściwość Metadata pozwala na osadzenie informacji o dokumencie, które pojawiają się we właściwościach pliku programu Excel, zgodnie ze standardami właściwości dokumentów firmy Microsoft, co pomaga w organizacji plików w środowiskach Enterprise. Dowiedz się więcej o edycji metadanych skoroszytu.
Metoda CreateWorkSheet() dodaje nowy arkusz o określonej nazwie. Znana z programu Excel notacja komórek (A1, B1 itp.) sprawia, że ustawianie wartości jest intuicyjne. IronXL automatycznie obsługuje konwersję typów danych, rozpoznając daty, liczby i tekst bez konieczności jawnego rzutowania. Metoda SaveAs() zapisuje kompletny plik Excel na dysku. Aby uzyskać więcej informacji na temat operacji na arkuszach, zapoznaj się z samouczkiem dotyczącym zarządzania arkuszami.
Podstawowy plik Excel wygenerowany przez IronXL, przedstawiający dane strukturalne z odpowiednimi nagłówkami kolumn.
IronXL oferuje wiele sposobów wypełniania komórek w Excelu, od przypisywania wartości do pojedynczych komórek po operacje na wielu komórkach naraz. Zrozumienie tych metod pomoże Ci wybrać najbardziej efektywne podejście do Twojego scenariusza danych. Przewodnik dotyczący wpisywania wartości w Excelu dokładnie omawia wszystkie dostępne opcje.
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales"); // C2
worksheet.SetCellValue(2, 2, "Marketing"); // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m; // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true; // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("EmployeeData.xlsx");Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Individual cell assignment
worksheet("A1").Value = "Employee Name"
worksheet("A2").Value = "John Smith"
worksheet("A3").Value = "Jane Doe"
' Range assignment for multiple cells
worksheet("B1:B3").Value = "Active"
' Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department") ' C1
worksheet.SetCellValue(1, 2, "Sales") ' C2
worksheet.SetCellValue(2, 2, "Marketing") ' C3
' Array-based population
Dim headers As String() = {"ID", "Name", "Email", "Phone"}
For i As Integer = 0 To headers.Length - 1
worksheet.SetCellValue(0, i, headers(i))
Next
' Working with different data types
worksheet("E1").Value = "Salary"
worksheet("E2").Value = 75000.5D ' Decimal for currency
worksheet("E3").Value = 82000.75D
worksheet("F1").Value = "Start Date"
worksheet("F2").Value = New DateTime(2020, 3, 15)
worksheet("F3").Value = New DateTime(2019, 7, 1)
worksheet("G1").Value = "Full Time"
worksheet("G2").Value = True ' Boolean
worksheet("G3").Value = True
workbook.SaveAs("EmployeeData.xlsx")Kod pokazuje elastyczne adresowanie komórek w IronXL. Notacja łańcuchowa ("A1") jest naturalna dla użytkowników programu Excel, natomiast indeksy numeryczne zapewniają programową kontrolę nad pętlami i dynamicznym generowaniem. Przypisania zakresów ("B1:B3") pozwalają efektywnie ustawić tę samą wartość w wielu komórkach, co idealnie nadaje się do inicjalizacji kolumn lub stosowania wartości domyślnych. Podczas pracy z nazwanymi zakresami lub nazwanymi tabelami IronXL zapewnia dodatkowe możliwości organizacyjne.
W przypadku większych zbiorów danych warto rozważyć następujący wzorzec:
// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
worksheet[$"A{row + 2}"].Value = employees[row].Id;
worksheet[$"B{row + 2}"].Value = employees[row].Name;
worksheet[$"C{row + 2}"].Value = employees[row].Department;
worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}' Populate from a data source
Dim employees = GetEmployeeData() ' Your data source
For row As Integer = 0 To employees.Count - 1
worksheet($"A{row + 2}").Value = employees(row).Id
worksheet($"B{row + 2}").Value = employees(row).Name
worksheet($"C{row + 2}").Value = employees(row).Department
worksheet($"D{row + 2}").Value = employees(row).Salary
NextTo podejście iteruje przez zbiór danych, mapując każdą właściwość do odpowiedniej kolumny. Interpolacja ciągów znaków ($"A{row + 2}") dynamicznie generuje adresy komórek, zaczynając od wiersza 2, aby zachować nagłówki. W przypadku pracy z dużymi zbiorami danych można dynamicznie dodawać wiersze i kolumny lub kopiować zakresy komórek w celu zwiększenia wydajności.
Arkusz kalkulacyjny z danymi pracowników, pokazujący różne typy danych i metody przypisywania komórek w IronXL.
Profesjonalne pliki Excel wymagają czegoś więcej niż tylko surowych danych. API stylizacji IronXL przekształca zwykłe arkusze kalkulacyjne w dopracowane dokumenty biznesowe poprzez formatowanie, kolory i hierarchię wizualną podczas generowania plików Excel w języku C#. Biblioteka zapewnia kompletne opcje formatowania komórek, umożliwiające tworzenie atrakcyjnych wizualnie arkuszy kalkulacyjnych.
using IronXL;
using IronXL.Formatting;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Add sample data first
worksheet["A1"].Value = "ID";
worksheet["B1"].Value = "Name";
worksheet["C1"].Value = "Department";
worksheet["D1"].Value = "Phone";
worksheet["E1"].Value = "Salary";
worksheet["F1"].Value = "Start Date";
worksheet["G1"].Value = "Full Time";
// Add employee data
worksheet["A2"].Value = 101;
worksheet["B2"].Value = "John Smith";
worksheet["C2"].Value = "Sales";
worksheet["D2"].Value = "(555) 123-4567";
worksheet["E2"].Value = 75000.50m;
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["G2"].Value = true;
worksheet["A3"].Value = 102;
worksheet["B3"].Value = "Jane Doe";
worksheet["C3"].Value = "Marketing";
worksheet["D3"].Value = "(555) 987-6543";
worksheet["E3"].Value = 82000.75m;
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G3"].Value = true;
// Header formatting
var headerRange = worksheet["A1:G1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.SetColumnWidth(1, 20); // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.SetColor("#000000");
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.LeftBorder.SetColor("#000000");
dataRange.Style.RightBorder.SetColor("#000000");
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
if (row % 2 == 0)
{
worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
}
}
workbook.SaveAs("FormattedEmployees.xlsx");Imports IronXL
Imports IronXL.Formatting
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Add sample data first
worksheet("A1").Value = "ID"
worksheet("B1").Value = "Name"
worksheet("C1").Value = "Department"
worksheet("D1").Value = "Phone"
worksheet("E1").Value = "Salary"
worksheet("F1").Value = "Start Date"
worksheet("G1").Value = "Full Time"
' Add employee data
worksheet("A2").Value = 101
worksheet("B2").Value = "John Smith"
worksheet("C2").Value = "Sales"
worksheet("D2").Value = "(555) 123-4567"
worksheet("E2").Value = 75000.5D
worksheet("F2").Value = New DateTime(2020, 3, 15)
worksheet("G2").Value = True
worksheet("A3").Value = 102
worksheet("B3").Value = "Jane Doe"
worksheet("C3").Value = "Marketing"
worksheet("D3").Value = "(555) 987-6543"
worksheet("E3").Value = 82000.75D
worksheet("F3").Value = New DateTime(2019, 7, 1)
worksheet("G3").Value = True
' Header formatting
Dim headerRange = worksheet("A1:G1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"
' Column width adjustment
worksheet.AutoSizeColumn(0) ' Auto-fit column A
worksheet.SetColumnWidth(1, 20) ' Set column B to 20 characters
' Number formatting
Dim salaryColumn = worksheet("E2:E3")
salaryColumn.FormatString = "$#,##0.00"
' Date formatting
Dim dateColumn = worksheet("F2:F3")
dateColumn.FormatString = "MM/dd/yyyy"
' Cell borders
Dim dataRange = worksheet("A1:G3")
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin
' To set border color, use:
dataRange.Style.TopBorder.SetColor("#000000")
dataRange.Style.BottomBorder.SetColor("#000000")
dataRange.Style.LeftBorder.SetColor("#000000")
dataRange.Style.RightBorder.SetColor("#000000")
' Text alignment
worksheet("A1:G1").Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
' Alternating row colors for readability
For row As Integer = 2 To 3
If row Mod 2 = 0 Then
worksheet($"A{row}:G{row}").Style.SetBackgroundColor("#F2F2F2")
End If
Next row
workbook.SaveAs("FormattedEmployees.xlsx")Ten kod formatowania zapewnia profesjonalny wygląd zgodny ze standardami Enterprise. Pogrubione nagłówki z wzorami i kolorami tła tworzą wizualną hierarchię. Metoda SetBackgroundColor() akceptuje kody kolorów hex, dając precyzyjną kontrolę nad twoim schematem kolorów. Właściwości czcionki obejmują opcje rozmiaru, koloru, pogrubienia, kursywy i podkreślenia, które są niezbędne do tworzenia plików Excel zgodnych z wytycznymi dotyczącymi identyfikacji wizualnej firmy. W przypadku zaawansowanych potrzeb stylistycznych warto zapoznać się z możliwościami formatowania warunkowego.
Dostosowanie szerokości kolumn zapobiega ucinaniu tekstu. AutoSizeColumn() automatycznie dopasowuje treść, podczas gdy SetColumnWidth() zapewnia dokładną kontrolę. Funkcja automatycznego dopasowywania rozmiaru wierszy i kolumn zapewnia optymalne wyświetlanie danych. Do formatowania liczb używa się kodów formatowania programu Excel — dowiedz się więcej o formatach liczb w Excelu, aby poznać wszystkie opcje formatowania.
Obramowania i wyrównanie komórek określają granice danych, poprawiając czytelność. Enum BorderType oferuje różne style: cienki, średni, gruby, kropkowany i przerywany. Opcje obramowania i wyrównania wyśrodkowują nagłówki i wyrównują liczby do prawej strony, zgodnie z konwencjami arkuszy kalkulacyjnych. Naprzemienne kolory wierszy, często nazywane "pasmami", pomagają czytelnikom śledzić informacje w rozległych zestawach danych.
Profesjonalnie sformatowany plik Excel prezentujący możliwości stylizacji IronXL w dokumentach korporacyjnych.
Formuły programu Excel ożywiają arkusze kalkulacyjne dzięki automatycznym obliczeniom. IronXL obsługuje tworzenie i obliczanie formuł, umożliwiając tworzenie dynamicznych arkuszy kalkulacyjnych, które aktualizują się automatycznie. Biblioteka obsługuje ponad 165 funkcji programu Excel i umożliwia edycję formuł programowo.
var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
{ 50000, 52000, 51000 },
{ 15000, 18000, 20000 },
{ 8000, 8500, 9000 },
{ 12000, 5000, 7000 },
{ 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
budget[$"A{i + 2}"].Value = categories[i];
budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
// Row total formula
budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");Imports System
Dim workbook = WorkBook.Create()
' Create a budget worksheet
Dim budget As WorkSheet = workbook.CreateWorkSheet("Q1 Budget")
' Headers
budget("A1").Value = "Category"
budget("B1").Value = "January"
budget("C1").Value = "February"
budget("D1").Value = "March"
budget("E1").Value = "Q1 Total"
' Budget categories and values
Dim categories As String() = {"Salaries", "Marketing", "Operations", "Equipment", "Training"}
Dim monthlyBudgets As Decimal(,) = {
{50000, 52000, 51000},
{15000, 18000, 20000},
{8000, 8500, 9000},
{12000, 5000, 7000},
{3000, 3500, 4000}
}
' Populate data
For i As Integer = 0 To categories.Length - 1
budget($"A{i + 2}").Value = categories(i)
budget($"B{i + 2}").Value = monthlyBudgets(i, 0)
budget($"C{i + 2}").Value = monthlyBudgets(i, 1)
budget($"D{i + 2}").Value = monthlyBudgets(i, 2)
' Row total formula
budget($"E{i + 2}").Formula = $"=SUM(B{i + 2}:D{i + 2})"
Next
' Monthly totals row
budget("A7").Value = "Monthly Total"
budget("B7").Formula = "=SUM(B2:B6)"
budget("C7").Formula = "=SUM(C2:C6)"
budget("D7").Formula = "=SUM(D2:D6)"
budget("E7").Formula = "=SUM(E2:E6)"
' Calculate percentages
budget("A9").Value = "Marketing %"
budget("B9").Formula = "=B3/B7*100"
budget("C9").Formula = "=C3/C7*100"
budget("D9").Formula = "=D3/D7*100"
' Average calculation
budget("A10").Value = "Average Spending"
budget("B10").Formula = "=AVERAGE(B2:B6)"
' Evaluate all formulas
workbook.EvaluateAll()
workbook.SaveAs("Budget.xlsx")Ten przykład budżetu ilustruje praktyczne zastosowanie wzoru. Właściwość Formuła akceptuje standardową składnię formuł programu Excel, zaczynającą się od znaku równości. IronXL obsługuje popularne funkcje: SUM, AVERAGE, COUNT, MAX, MIN i wiele innych. Odwołania do komórek w formułach działają dokładnie tak samo jak w programie Excel, w tym odwołania względne i bezwzględne. Aby uzyskać dostęp do bardziej zaawansowanych obliczeń, zapoznaj się z funkcjami agregującymi programu Excel oraz formułami programu Excel w języku C#.
Gdy formuły nie działają zgodnie z oczekiwaniami:
=EvaluateAll(): Wymagane przed zapisaniem, aby zobaczyć wynikiMetoda EvaluateAll() przetwarza wszystkie formuły, aktualizując obliczone wartości w całym skoroszycie. Dzięki temu formuły wyświetlają wyniki po otwarciu w programie Excel. Bez oceny program Excel wyświetlałby formuły do momentu, aż użytkownik uruchomiłby ponowne obliczenia. W przypadku złożonych scenariuszy wykorzystujących formuły Excela w języku C#, IronXL zapewnia kompleksowe wsparcie.
Arkusz kalkulacyjny z aktywnymi formułami, automatycznie obliczającymi sumy i wartości procentowe.
W praktyce dane z baz danych są często eksportowane do programu Excel w celu sporządzenia raportów i przeprowadzenia analizy. IronXL upraszcza ten proces z wbudowanym wsparciem DataTable, eliminując ręczne mapowanie pól podczas generowania plików Excel z aplikacji C#. Biblioteka udostępnia wiele metod integracji z bazami danych oraz zapewnia kompatybilność z DataGrid.
using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
DataTable dt = new DataTable("Sales");
dt.Columns.Add("OrderID", typeof(int));
dt.Columns.Add("CustomerName", typeof(string));
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Quantity", typeof(int));
dt.Columns.Add("UnitPrice", typeof(decimal));
dt.Columns.Add("OrderDate", typeof(DateTime));
// Sample data (normally from database)
dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
for (int col = 0; col < salesData.Columns.Count; col++)
{
reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
}
// Add total column with formula
reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");Imports System.Data
Imports System.Data.SqlClient
' Simulate database retrieval (replace with your actual database code)
Function GetSalesData() As DataTable
Dim dt As New DataTable("Sales")
dt.Columns.Add("OrderID", GetType(Integer))
dt.Columns.Add("CustomerName", GetType(String))
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Quantity", GetType(Integer))
dt.Columns.Add("UnitPrice", GetType(Decimal))
dt.Columns.Add("OrderDate", GetType(DateTime))
' Sample data (normally from database)
dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99D, DateTime.Now.AddDays(-5))
dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99D, DateTime.Now.AddDays(-4))
dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99D, DateTime.Now.AddDays(-3))
dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99D, DateTime.Now.AddDays(-2))
dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99D, DateTime.Now.AddDays(-1))
Return dt
End Function
' Export to Excel
Dim reportWorkbook As WorkBook = WorkBook.Create()
Dim reportSheet As WorkSheet = reportWorkbook.CreateWorkSheet("Sales Report")
' Get data from database
Dim salesData As DataTable = GetSalesData()
' Method 1: Manual mapping with formatting
reportSheet("A1").Value = "Order Report - " & DateTime.Now.ToString("MMMM yyyy")
reportSheet.Merge("A1:F1")
reportSheet("A1").Style.Font.Bold = True
reportSheet("A1").Style.Font.Height = 14
' Headers
Dim headerRow As Integer = 3
For col As Integer = 0 To salesData.Columns.Count - 1
reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns(col).ColumnName)
Next
' Format headers
Dim headers = reportSheet($"A{headerRow}:F{headerRow}")
headers.Style.Font.Bold = True
headers.Style.SetBackgroundColor("#D9E1F2")
' Data rows
For row As Integer = 0 To salesData.Rows.Count - 1
For col As Integer = 0 To salesData.Columns.Count - 1
reportSheet.SetCellValue(row + headerRow, col, salesData.Rows(row)(col))
Next
' Add total column with formula
reportSheet($"G{row + headerRow + 1}").Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}"
Next
' Add total header and format
reportSheet("G3").Value = "Total"
reportSheet("G3").Style.Font.Bold = True
reportSheet("G3").Style.SetBackgroundColor("#D9E1F2")
' Format currency columns
reportSheet($"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
reportSheet($"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
' Format date column
reportSheet($"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}").FormatString = "MM/dd/yyyy"
' Add summary section
Dim summaryRow As Integer = headerRow + salesData.Rows.Count + 2
reportSheet($"A{summaryRow}").Value = "Summary"
reportSheet($"A{summaryRow}").Style.Font.Bold = True
reportSheet($"A{summaryRow + 1}").Value = "Total Orders:"
reportSheet($"B{summaryRow + 1}").Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})"
reportSheet($"A{summaryRow + 2}").Value = "Total Revenue:"
reportSheet($"B{summaryRow + 2}").Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})"
reportSheet($"B{summaryRow + 2}").FormatString = "$#,##0.00"
' Auto-fit columns
For col As Integer = 0 To 6
reportSheet.AutoSizeColumn(col)
Next
' Evaluate formulas and save
reportWorkbook.EvaluateAll()
reportWorkbook.SaveAs("DatabaseExport.xlsx")Ten obszerny przykład ilustruje kompletny proces tworzenia plików Excel z bazy danych w języku C#. Metoda DataTable symuluje pobieranie z bazy danych - w produkcji zastąp to swoimi rzeczywistymi zapytaniami do bazy danych używając Entity Framework, Dapper lub ADO.NET. Aby uzyskać bezpośrednią integrację z SQL, zapoznaj się z możliwością wczytywania plików Excel z baz danych SQL lub aktualizowania rekordów bazy danych z poziomu programu Excel.
W przypadku eksportu dużych baz danych należy wziąć pod uwagę:
Kod tworzy profesjonalny raport z tytułem, sformatowanymi nagłówkami i wierszami danych. Kolumny formuł obliczają sumy wierszy dynamicznie. W sekcji podsumowania wykorzystano formuły programu Excel do zliczania zamówień i sumowania przychodów, co gwarantuje aktualizację tych wartości w przypadku zmiany danych. Aby pracować z DataSets zamiast DataTables, zobacz przewodnik export dataset datatable.
Profesjonalny raport sprzedaży generowany na podstawie danych z bazy danych z automatycznymi obliczeniami i formatowaniem.
Chcesz usprawnić tworzenie raportów w Excelu? Zdobądź licencję, aby w pełni wykorzystać potencjał IronXL w środowisku produkcyjnym.
Złożone pliki Excel często wymagają wielu arkuszy do uporządkowania powiązanych danych. IronXL upraszcza zarządzanie wieloma arkuszami dzięki intuicyjnym metodom tworzenia, uzyskiwania dostępu i organizowania arkuszy. Dowiedz się więcej o zarządzaniu arkuszami i kopiowaniu danych z arkuszy w zaawansowanych scenariuszach.
// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
salesSheet[$"A{i + 4}"].Value = regions[i];
salesSheet[$"B{i + 4}"].Value = q1Sales[i];
salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
inventorySheet[$"A{i + 4}"].Value = products[i];
inventorySheet[$"B{i + 4}"].Value = stock[i];
inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
// Status based on stock level
string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
inventorySheet[$"D{i + 4}"].Value = status;
// Color code status
if (status == "REORDER")
{
inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
// Format headers
sheet["A1"].Style.Font.Bold = true;
sheet["A1"].Style.Font.Height = 14;
var headerRow = sheet["A3:D3"];
headerRow.Style.Font.Bold = true;
headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");Imports System
' Create a multi-sheet workbook
Dim companyReport As WorkBook = WorkBook.Create()
' Create department sheets
Dim salesSheet As WorkSheet = companyReport.CreateWorkSheet("Sales")
Dim inventorySheet As WorkSheet = companyReport.CreateWorkSheet("Inventory")
Dim hrSheet As WorkSheet = companyReport.CreateWorkSheet("HR Metrics")
' Populate Sales sheet
salesSheet("A1").Value = "Sales Dashboard"
salesSheet("A3").Value = "Region"
salesSheet("B3").Value = "Q1 Sales"
salesSheet("C3").Value = "Q2 Sales"
Dim regions As String() = {"North", "South", "East", "West"}
Dim q1Sales As Decimal() = {250000D, 180000D, 220000D, 195000D}
Dim q2Sales As Decimal() = {275000D, 195000D, 240000D, 210000D}
For i As Integer = 0 To regions.Length - 1
salesSheet($"A{i + 4}").Value = regions(i)
salesSheet($"B{i + 4}").Value = q1Sales(i)
salesSheet($"C{i + 4}").Value = q2Sales(i)
Next
' Populate Inventory sheet
inventorySheet("A1").Value = "Inventory Status"
inventorySheet("A3").Value = "Product"
inventorySheet("B3").Value = "Stock Level"
inventorySheet("C3").Value = "Reorder Point"
inventorySheet("D3").Value = "Status"
' Add inventory data with conditional status
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim stock As Integer() = {150, 45, 200}
Dim reorderPoint As Integer() = {100, 50, 75}
For i As Integer = 0 To products.Length - 1
inventorySheet($"A{i + 4}").Value = products(i)
inventorySheet($"B{i + 4}").Value = stock(i)
inventorySheet($"C{i + 4}").Value = reorderPoint(i)
' Status based on stock level
Dim status As String = If(stock(i) <= reorderPoint(i), "REORDER", "OK")
inventorySheet($"D{i + 4}").Value = status
' Color code status
If status = "REORDER" Then
inventorySheet($"D{i + 4}").Style.Font.Color = "#FF0000"
End If
Next
' Create summary sheet referencing other sheets
Dim summarySheet As WorkSheet = companyReport.CreateWorkSheet("Summary")
summarySheet("A1").Value = "Company Overview"
summarySheet("A3").Value = "Metric"
summarySheet("B3").Value = "Value"
summarySheet("A4").Value = "Total Q1 Sales"
summarySheet("B4").Formula = "=SUM(Sales!B4:B7)"
summarySheet("A5").Value = "Total Q2 Sales"
summarySheet("B5").Formula = "=SUM(Sales!C4:C7)"
summarySheet("A6").Value = "Products Need Reorder"
summarySheet("B6").Formula = "=COUNTIF(Inventory!D4:D6,""REORDER"")"
' Format all sheets consistently
For Each sheet As WorkSheet In companyReport.WorkSheets
' Format headers
sheet("A1").Style.Font.Bold = True
sheet("A1").Style.Font.Height = 14
Dim headerRow = sheet("A3:D3")
headerRow.Style.Font.Bold = True
headerRow.Style.SetBackgroundColor("#E7E6E6")
Next
' Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx")Ten przykład tworzy kompletny raport wielostronicowy. Każdy arkusz służy konkretnemu celowi: danym sprzedażowym, śledzeniu zapasów i wskaźnikom kadrowym. Arkusz podsumowujący konsoliduje kluczowe wskaźniki przy użyciu formuł międzyarkuszowych. Zwróć uwagę na składnię odwołania do arkusza w formułach - "Sales!B4:B7" odnosi się do komórek B4 do B7 na arkuszu Sprzedaż. W przypadku bardziej złożonych operacji warto rozważyć łączenie zakresów w Excelu oraz grupowanie wierszy i kolumn.
Arkusz inwentaryzacyjny wykorzystuje logikę warunkową, zaznaczając na czerwono pozycje o niskim stanie magazynowym, aby zwrócić na nie natychmiastową uwagę. Pętla foreach stosuje spójne formatowanie we wszystkich arkuszach, zapewniając profesjonalny wygląd całego skoroszytu. Nazwy arkuszy pojawiają się w programie Excel jako zakładki, co pozwala użytkownikom na łatwe przechodzenie między różnymi widokami danych. W przypadku zaawansowanych scenariuszy warto rozważyć dodanie zamrożonych okienek, aby nagłówki pozostawały widoczne podczas przewijania dużych zbiorów danych.
Wydajne generowanie plików Excel w języku C# wymaga przemyślanego podejścia do wykorzystania pamięci, obsługi błędów i wdrażania. Te praktyki zapewniają skuteczne skalowanie aplikacji przy zachowaniu niezawodności podczas programowego tworzenia arkuszy kalkulacyjnych Excel. Zapoznaj się z najlepszymi praktykami w zakresie bezpieczeństwa i opcjami ochrony plików dla wdrożeń Enterprise.
Zarządzanie pamięcią staje się kluczowe w przypadku dużych plików. Zamiast ładować całe zbiory danych do pamięci, przetwarzaj dane w fragmentach:
// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 1;
// Process in batches
foreach (var batch in GetDataInBatches(rowsPerBatch))
{
foreach (var record in batch)
{
sheet[$"A{currentRow}"].Value = record.Id;
sheet[$"B{currentRow}"].Value = record.Name;
sheet[$"C{currentRow}"].Value = record.Value;
currentRow++;
}
}
workbook.SaveAs(filename);
}' Process large datasets efficiently
Public Sub ExportLargeDataset(filename As String)
Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
Dim rowsPerBatch As Integer = 1000
Dim currentRow As Integer = 1
' Process in batches
For Each batch In GetDataInBatches(rowsPerBatch)
For Each record In batch
sheet($"A{currentRow}").Value = record.Id
sheet($"B{currentRow}").Value = record.Name
sheet($"C{currentRow}").Value = record.Value
currentRow += 1
Next
Next
workbook.SaveAs(filename)
End SubDevOps?| Problem | Rozwiązanie | Zapobieganie |
|---|---|---|
| Brak pamięci | Przetwarzaj partiami | Monitoruj wielkość partii |
| Blokady plików | Używaj strumieni, a nie plików | Wprowadź odpowiednią utylizację |
| Błędy licencji | Weryfikacja licencji w kodzie | Prawidłowe zastosowanie licencji |
| Wydajność | Włącz operacje asynchroniczne | Wąskie gardła profilu |
| Problemy z kontenerami | Zainstaluj zależności | Przetestuj lokalnie w Dockerze |
Obsługa błędów zapobiega awariom aplikacji i zapewnia przydatne informacje zwrotne podczas generowania plików Excel:
try
{
WorkBook workbook = WorkBook.Create();
// Excel generation code
workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
// Log the error
Console.WriteLine($"Excel generation failed: {ex.Message}");
// Implement appropriate recovery or notification
}Imports System
Try
Dim workbook As WorkBook = WorkBook.Create()
' Excel generation code
workbook.SaveAs("output.xlsx")
Catch ex As Exception
' Log the error
Console.WriteLine($"Excel generation failed: {ex.Message}")
' Implement appropriate recovery or notification
End TryW przypadku aplikacji internetowych generuj pliki Excel w pamięci i przesyłaj je strumieniowo do użytkowników. Takie podejście doskonale sprawdza się w przypadku aplikacji ASP.NET MVC:
// ASP.NET Core example
public IActionResult DownloadExcel()
{
WorkBook workbook = GenerateReport();
var stream = new MemoryStream();
workbook.SaveAs(stream);
stream.Position = 0;
return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Public Function DownloadExcel() As IActionResult
Dim workbook As WorkBook = GenerateReport()
Dim stream As New MemoryStream()
workbook.SaveAs(stream)
stream.Position = 0
Return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx")
End FunctionUwzględnienie kwestii związanych z wdrożeniem zapewnia płynne działanie środowiska produkcyjnego. IronXL działa w środowiskach o ograniczonych uprawnieniach, bez konieczności posiadania uprawnień administratora, dzięki czemu nadaje się do hostingu współdzielonego i wdrożeń kontenerowych. Dołącz plik licencji IronXL do pakietu instalacyjnego i upewnij się, że aplikacja ma uprawnienia do zapisu w celu obsługi plików tymczasowych, jeśli to konieczne. Aby uzyskać informacje na temat prawidłowej konfiguracji licencji, zapoznaj się z sekcją dotyczącą korzystania z kluczy licencyjnych oraz konfiguracji pliku web.config.
W przypadku wdrożeń Docker:
FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
COPY . .
# Zainstaluj zależności for Excel operations
RUN apt-get update && apt-get install -y libgdiplus
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENTRYPOINT ["dotnet", "YourApp.dll"]Podczas pracy z danymi wrażliwymi warto rozważyć zabezpieczenie skoroszytów hasłem oraz zabezpieczenie arkuszy. IronXL zapewnia kompleksowe funkcje bezpieczeństwa, chroniące pliki Excel przed nieautoryzowanym dostępem. Aby uzyskać optymalną wydajność w przypadku dużych plików, należy wdrożyć strategie przycinania danych i czyszczenia komórek w celu efektywnego zarządzania rozmiarem plików.
W przypadku wdrożeń w systemie Linux należy zapewnić prawidłową konfigurację zgodnie z instrukcją konfiguracji dla systemu Linux. W przypadku wdrażania w AWS Lambda należy zapoznać się z przewodnikiem wdrożeniowym AWS, aby uzyskać informacje na temat konfiguracji specyficznych dla środowiska bezserwerowego.
IronXL zmienia generowanie plików Excel w języku C# ze skomplikowanego wyzwania w proste kodowanie. Nauczyłeś się tworzyć skoroszyty, wypełniać komórki, stosować formatowanie, używać formuł i eksportować dane z baz danych — wszystko to bez konieczności korzystania z pakietu Microsoft Office. Te techniki programowego generowania plików Excel działają spójnie w systemach Windows, Linux i na platformach chmurowych.
Aby zapoznać się z zaawansowanymi funkcjami, odwiedź:
Chcesz wdrożyć generowanie plików Excel w swoich aplikacjach C#? Bezpłatna próba lub zapoznaj się z obszerną dokumentacją API, aby poznać zaawansowane funkcje. W przypadku wdrożeń produkcyjnych zapoznaj się z opcjami licencyjnymi, które odpowiadają wymaganiom Twojego projektu. W miarę wzrostu potrzeb warto rozważyć rozszerzenia licencji i ścieżki aktualizacji.
Elastyczne opcje licencyjne dostosowane do Twoich potrzeb w zakresie generowania plików Excel, od etapu rozwoju po wdrożenie w przedsiębiorstwie.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
