Jak utworzyć plik Excel w C#

How to Create an Excel File in C# (.NET Tutorial)

This article was translated from English: Does it need improvement?
Translated
View the article in English

Większość zespołów, z którymi pracuję, potrzebuje generować pliki Excel przynajmniej równie często, jak je odczytują: faktury, eksporty, miesięczne raporty, które zespół finansowy może otworzyć i filtrować. Zbudowałem ten przepływ dziesiątki razy w aplikacjach konsolowych, usługach ASP.NET i pracownikach w tle. API IronXL jest na tyle bliskie sposobowi, w jaki myśli samo Excel, że kod czyta się niemal jak specyfikacja, ale są pewne decyzje dotyczące formatowania i zapisu, które są bardziej istotne niż powierzchnia API daje do zrozumienia. Ten przewodnik opisuje, jak faktycznie generuję pliki XLSX w produkcji, w tym haczyki, które kosztowały mnie czas przy pierwszych kilku razach.

Biblioteka działa na .NET 8, .NET 9, .NET Core i .NET Framework na Windows, Linux, macOS, Azure i AWS, bez potrzeby korzystania z Microsoft Office na hoście. Ścieżki kodu poniżej są takie same we wszystkich tych celach.

Szybki start: Tworzenie pliku Excel

Trzy linie tworzą nowy skoroszyt, wpisują wartość do A1 i zapisują plik na dysku. Nie ma w tym procesu Excela, brak serializacji COM.

  1. Install IronXL with NuGet Package Manager

    PM > Install-Package IronXL.Excel
  2. Skopiuj i uruchom ten fragment kodu.

    WorkBook book = IronXL.WorkBook.Create(IronXL.ExcelFileFormat.XLSX); book.CreateWorkSheet("Sheet1")["A1"].Value = "Hello World"; book.SaveAs("MyFile.xlsx");
  3. Wdrożenie do testowania w środowisku produkcyjnym

    Rozpocznij używanie IronXL w swoim projekcie już dziś z darmową wersją próbną

    arrow pointer

Czym jest IronXL i dlaczego używać go do tworzenia plików Excel?

IronXL to API Excela dla C# i VB.NET do odczytu, edycji i tworzenia plików arkuszy kalkulacyjnych. Nie wymaga Microsoft Office ani Excel Interop, co upraszcza wdrożenie do odniesienia NuGet i instrukcji using.

IronXL w pełni obsługuje .NET 9, .NET 8, .NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS i środowiska Azure.

Funkcje IronXL

  • Bezpośrednie wsparcie od naszego zespołu deweloperów .NET
  • Szybka instalacja za pomocą Microsoft Visual Studio
  • DARMOWE dla rozwoju. Licencje z $999

Jak szybko utworzyć i zapisać plik Excel?

Zainstaluj IronXL przez NuGet lub pobierz DLL bezpośrednio. Klasa WorkBook jest punktem wejścia dla wszystkich operacji Excel, a klasa WorkSheet udostępnia metody do manipulowania poszczególnymi arkuszami. Pełne, krok po kroku, przeprowadzenie zaczyna się od Krok 1 poniżej.


How Do I Install the IronXL C# Library?

Zainstaluj IronXL przez Menedżera Pakietów NuGet w Visual Studio lub użyj Konsoli Menedżera Pakietów:

Install-Package IronXL.Excel

Uzyskaj dostęp do Menedżera Pakietów NuGet przez menu Projekt lub klikając prawym przyciskiem myszy na projekt w Eksploratorze Rozwiązań.

Menu Projekt w Visual Studio pokazujące opcję Zarządzaj Pakietami NuGet Rysunek 3 - Dostęp do Menedżera Pakietów NuGet przez menu Projektu

Menu kontekstowe Eksploratora Rozwiązań wyświetlające opcję Zarządzaj Pakietami NuGet Rysunek 4 - Menu kontekstowe po kliknięciu prawym przyciskiem myszy w Eksploratorze Rozwiązań

Wyszukaj IronXL.Excel w liście pakietów i kliknij Zainstaluj.


Menedżer Pakietów NuGet pokazujący pakiet IronXL.Excel gotowy do instalacji Rysunek 5 - Instalacja IronXL.Excel przez Menedżera Pakietów NuGet

Alternatywnie, pobierz plik DLL IronXL bezpośrednio i dodaj go jako odniesienie do projektu za pośrednictwem Eksploratora Rozwiązań > Referencje > Wyszukaj IronXL.dll.

Strona pobierania IronXL pokazująca instrukcje instalacji i przycisk pobierania Rysunek 6 - Pobierz biblioteki IronXL z oficjalnej strony internetowej

Zwróć uwagęIronXL nie wymaga instalacji Microsoft Office ani Excel Interop. Działa na dowolnej platformie obsługiwanej przez .NET, w tym Windows, Linux, macOS i środowiskach chmurowych.)}


Jak skonfigurować projekt .NET?

IronXL działa z dowolnym typem projektu .NET: aplikacjami konsolowymi, aplikacjami webowymi ASP.NET, API lub narzędziami desktopowymi. Poniższy przykład używa aplikacji webowej ASP.NET, ale te same ścieżki kodu działają we wszystkich szablonach projektów.

Postępuj zgodnie z tymi krokami, aby utworzyć stronę internetową ASP.NET:

  1. Otwórz Visual Studio
  2. Kliknij Plik > Nowy Projekt
  3. Wybierz Web w kategorii Visual C# na liście typów projektów
  4. Wybierz Aplikację Webową ASP.NET


    Okno dialogowe Nowy Projekt w Visual Studio z wybraną Aplikacją Webową ASP.NET

    Rysunek 1Create new ASP.NET project

  5. Kliknij OK
  6. Wybierz szablon Web Forms

    Szablon projektu ASP.NET pokazujący opcję Web Forms

    Rysunek 2Select Web Forms template

  7. Kliknij OK

Po przygotowaniu projektu, zainstaluj IronXL, aby zacząć tworzyć pliki Excel programatycznie.


How Do I Create an Excel Workbook in C#?

Nowy skoroszyt to jedno wywołanie do WorkBook.Create, z formatem pliku przekazywanym jako wyliczenie:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-3.cs
WorkSheet workSheet = workBook.CreateWorkSheet("2020 Budget");
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("2020 Budget")
$vbLabelText   $csharpLabel

Metoda Create obsługuje zarówno format XLS (Excel 97-2003), jak i XLSX (Excel 2007+). XLSX jest zalecany dla lepszej wydajności i mniejszych rozmiarów plików.

  • XLSX: Zalecany dla wszystkich nowoczesnych wersji Excel (2007+) — mniejsze pliki, lepsza wydajność
  • XLS: Format starszy dla zgodności z Excel 97–2003

Jak dodać arkusz do skoroszytu?

Dodaj arkusze za pomocą CreateWorkSheet:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-4.cs
workSheet["A1"].Value = "January";
workSheet["B1"].Value = "February";
workSheet["C1"].Value = "March";
workSheet["D1"].Value = "April";
workSheet["E1"].Value = "May";
workSheet["F1"].Value = "June";
workSheet["G1"].Value = "July";
workSheet["H1"].Value = "August";
workSheet["I1"].Value = "September";
workSheet["J1"].Value = "October";
workSheet["K1"].Value = "November";
workSheet["L1"].Value = "December";
workSheet("A1").Value = "January"
workSheet("B1").Value = "February"
workSheet("C1").Value = "March"
workSheet("D1").Value = "April"
workSheet("E1").Value = "May"
workSheet("F1").Value = "June"
workSheet("G1").Value = "July"
workSheet("H1").Value = "August"
workSheet("I1").Value = "September"
workSheet("J1").Value = "October"
workSheet("K1").Value = "November"
workSheet("L1").Value = "December"
$vbLabelText   $csharpLabel

Skoroszyt zawiera jeden lub więcej arkuszy. Każdy arkusz składa się z wierszy i kolumn, z komórkami na ich przecięciach. Użyj metody CreateWorkSheet, aby dodać nowe arkusze do swojego skoroszytu.

  • WorkBook.CreateWorkSheet(String): Dodaje nowy arkusz z podaną nazwą zakładki
  • WorkSheet: Pobiera istniejący arkusz według nazwy
  • Nazwy arkuszy muszą być unikalne w ramach skoroszytu

Jak ustawić wartości komórek w Excelu?

Jak mogę ręcznie ustawić wartości komórek?

Dostęp do komórek używa tych samych ciągów adresów w stylu A1, które widzisz w Excelu:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-5.cs
Random r = new Random();
for (int i = 2 ; i <= 11 ; i++)
{
    workSheet["A" + i].Value = r.Next(1, 1000);
    workSheet["B" + i].Value = r.Next(1000, 2000);
    workSheet["C" + i].Value = r.Next(2000, 3000);
    workSheet["D" + i].Value = r.Next(3000, 4000);
    workSheet["E" + i].Value = r.Next(4000, 5000);
    workSheet["F" + i].Value = r.Next(5000, 6000);
    workSheet["G" + i].Value = r.Next(6000, 7000);
    workSheet["H" + i].Value = r.Next(7000, 8000);
    workSheet["I" + i].Value = r.Next(8000, 9000);
    workSheet["J" + i].Value = r.Next(9000, 10000);
    workSheet["K" + i].Value = r.Next(10000, 11000);
    workSheet["L" + i].Value = r.Next(11000, 12000);
}
Dim r As New Random()
For i As Integer = 2 To 11
	workSheet("A" & i).Value = r.Next(1, 1000)
	workSheet("B" & i).Value = r.Next(1000, 2000)
	workSheet("C" & i).Value = r.Next(2000, 3000)
	workSheet("D" & i).Value = r.Next(3000, 4000)
	workSheet("E" & i).Value = r.Next(4000, 5000)
	workSheet("F" & i).Value = r.Next(5000, 6000)
	workSheet("G" & i).Value = r.Next(6000, 7000)
	workSheet("H" & i).Value = r.Next(7000, 8000)
	workSheet("I" & i).Value = r.Next(8000, 9000)
	workSheet("J" & i).Value = r.Next(9000, 10000)
	workSheet("K" & i).Value = r.Next(10000, 11000)
	workSheet("L" & i).Value = r.Next(11000, 12000)
Next i
$vbLabelText   $csharpLabel

Właściwość Value akceptuje różne typy danych, w tym ciągi, liczby, daty i wartości logiczne. IronXL automatycznie formatuje komórki na podstawie typu danych.

Jak dynamicznie ustawić wartości komórek?

Gdy liczba wierszy jest znana w czasie działania, interpolacja ciągów czyni ciało pętli łatwym do odczytania:

// Initialize random number generator for sample data
Random r = new Random();

// Populate cells with random budget data for each month
for (int i = 2; i <= 11; i++)
{
    // Set different budget categories with increasing ranges
    workSheet[$"A{i}"].Value = r.Next(1, 1000);     // Office Supplies
    workSheet[$"B{i}"].Value = r.Next(1000, 2000);  // Utilities
    workSheet[$"C{i}"].Value = r.Next(2000, 3000);  // Rent
    workSheet[$"D{i}"].Value = r.Next(3000, 4000);  // Salaries
    workSheet[$"E{i}"].Value = r.Next(4000, 5000);  // Marketing
    workSheet[$"F{i}"].Value = r.Next(5000, 6000);  // IT Services
    workSheet[$"G{i}"].Value = r.Next(6000, 7000);  // Travel
    workSheet[$"H{i}"].Value = r.Next(7000, 8000);  // Training
    workSheet[$"I{i}"].Value = r.Next(8000, 9000);  // Insurance
    workSheet[$"J{i}"].Value = r.Next(9000, 10000); // Equipment
    workSheet[$"K{i}"].Value = r.Next(10000, 11000); // Research
    workSheet[$"L{i}"].Value = r.Next(11000, 12000); // Misc
}

// Alternative: Set range of cells with same value
workSheet["A13:L13"].Value = 0; // Initialize totals row
// Initialize random number generator for sample data
Random r = new Random();

// Populate cells with random budget data for each month
for (int i = 2; i <= 11; i++)
{
    // Set different budget categories with increasing ranges
    workSheet[$"A{i}"].Value = r.Next(1, 1000);     // Office Supplies
    workSheet[$"B{i}"].Value = r.Next(1000, 2000);  // Utilities
    workSheet[$"C{i}"].Value = r.Next(2000, 3000);  // Rent
    workSheet[$"D{i}"].Value = r.Next(3000, 4000);  // Salaries
    workSheet[$"E{i}"].Value = r.Next(4000, 5000);  // Marketing
    workSheet[$"F{i}"].Value = r.Next(5000, 6000);  // IT Services
    workSheet[$"G{i}"].Value = r.Next(6000, 7000);  // Travel
    workSheet[$"H{i}"].Value = r.Next(7000, 8000);  // Training
    workSheet[$"I{i}"].Value = r.Next(8000, 9000);  // Insurance
    workSheet[$"J{i}"].Value = r.Next(9000, 10000); // Equipment
    workSheet[$"K{i}"].Value = r.Next(10000, 11000); // Research
    workSheet[$"L{i}"].Value = r.Next(11000, 12000); // Misc
}

// Alternative: Set range of cells with same value
workSheet["A13:L13"].Value = 0; // Initialize totals row
' Initialize random number generator for sample data
Dim r As New Random()

' Populate cells with random budget data for each month
For i As Integer = 2 To 11
	' Set different budget categories with increasing ranges
	workSheet($"A{i}").Value = r.Next(1, 1000) ' Office Supplies
	workSheet($"B{i}").Value = r.Next(1000, 2000) ' Utilities
	workSheet($"C{i}").Value = r.Next(2000, 3000) ' Rent
	workSheet($"D{i}").Value = r.Next(3000, 4000) ' Salaries
	workSheet($"E{i}").Value = r.Next(4000, 5000) ' Marketing
	workSheet($"F{i}").Value = r.Next(5000, 6000) ' IT Services
	workSheet($"G{i}").Value = r.Next(6000, 7000) ' Travel
	workSheet($"H{i}").Value = r.Next(7000, 8000) ' Training
	workSheet($"I{i}").Value = r.Next(8000, 9000) ' Insurance
	workSheet($"J{i}").Value = r.Next(9000, 10000) ' Equipment
	workSheet($"K{i}").Value = r.Next(10000, 11000) ' Research
	workSheet($"L{i}").Value = r.Next(11000, 12000) ' Misc
Next i

' Alternative: Set range of cells with same value
workSheet("A13:L13").Value = 0 ' Initialize totals row
$vbLabelText   $csharpLabel

Interpolacja ciągów ($"...") ułatwia dynamiczne odwoływanie się do komórek. Indeksator Item obsługuje zarówno pojedyncze komórki, jak i zakresy.

Jak załadować dane do Excela z bazy danych?

Ładowanie danych z baz danych do Excela jest powszechnym wymaganiem:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-7.cs
workSheet["A1:L1"].Style.SetBackgroundColor("#d3d3d3");
workSheet("A1:L1").Style.SetBackgroundColor("#d3d3d3")
$vbLabelText   $csharpLabel

Ten przykład demonstruje czytanie danych Excel z baz danych, stosowanie formatowania i używanie formuł do obliczeń. Właściwość NumberFormat umożliwia dostosowywanie formatu liczb, tak jak w Excelu.


Jak stosować formatowanie do komórek Excel?

Jak mogę ustawić kolory tła w Excelu?

Tła, naprzemienne kolory wierszy i nadpisywanie kolorów czcionek są realizowane przez obiekt Style na komórce lub zakresie:

// Set header row background to light gray using hex color
workSheet["A1:L1"].Style.SetBackgroundColor("#d3d3d3");

// Apply different colors for data categorization
workSheet["A2:A11"].Style.SetBackgroundColor("#E7F3FF"); // Light blue for January
workSheet["B2:B11"].Style.SetBackgroundColor("#FFF2CC"); // Light yellow for February

// Highlight important cells with bold colors
workSheet["L12"].Style.SetBackgroundColor("#FF0000"); // Red for totals
workSheet["L12"].Style.Font.FontColor = "#FFFFFF"; // White text

// Create alternating row colors for better readability
for (int row = 2; row <= 11; row++)
{
    if (row % 2 == 0)
    {
        workSheet[$"A{row}:L{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
// Set header row background to light gray using hex color
workSheet["A1:L1"].Style.SetBackgroundColor("#d3d3d3");

// Apply different colors for data categorization
workSheet["A2:A11"].Style.SetBackgroundColor("#E7F3FF"); // Light blue for January
workSheet["B2:B11"].Style.SetBackgroundColor("#FFF2CC"); // Light yellow for February

// Highlight important cells with bold colors
workSheet["L12"].Style.SetBackgroundColor("#FF0000"); // Red for totals
workSheet["L12"].Style.Font.FontColor = "#FFFFFF"; // White text

// Create alternating row colors for better readability
for (int row = 2; row <= 11; row++)
{
    if (row % 2 == 0)
    {
        workSheet[$"A{row}:L{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
' Set header row background to light gray using hex color
workSheet("A1:L1").Style.SetBackgroundColor("#d3d3d3")

' Apply different colors for data categorization
workSheet("A2:A11").Style.SetBackgroundColor("#E7F3FF") ' Light blue for January
workSheet("B2:B11").Style.SetBackgroundColor("#FFF2CC") ' Light yellow for February

' Highlight important cells with bold colors
workSheet("L12").Style.SetBackgroundColor("#FF0000") ' Red for totals
workSheet("L12").Style.Font.FontColor = "#FFFFFF" ' White text

' Create alternating row colors for better readability
For row As Integer = 2 To 11
	If row Mod 2 = 0 Then
		workSheet($"A{row}:L{row}").Style.SetBackgroundColor("#F2F2F2")
	End If
Next row
$vbLabelText   $csharpLabel

Metoda SetBackgroundColor akceptuje kody kolorów w formacie hex. Łącz kolory tła z Font.FontColor, aby utrzymać czytelność kontrastu na ciemniejszych wypełnieniach.

Jak utworzyć obramowania w Excelu?

Obramowania pomagają definiować obszary danych i poprawić strukturę:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-9.cs
// Use IronXL built-in aggregations
decimal sum = workSheet["A2:A11"].Sum();
decimal avg = workSheet["B2:B11"].Avg();
decimal max = workSheet["C2:C11"].Max();
decimal min = workSheet["D2:D11"].Min();

// Assign value to cells
workSheet["A12"].Value = sum;
workSheet["B12"].Value = avg;
workSheet["C12"].Value = max;
workSheet["D12"].Value = min;
' Use IronXL built-in aggregations
Dim sum As Decimal = workSheet("A2:A11").Sum()
Dim avg As Decimal = workSheet("B2:B11").Avg()
Dim max As Decimal = workSheet("C2:C11").Max()
Dim min As Decimal = workSheet("D2:D11").Min()

' Assign value to cells
workSheet("A12").Value = sum
workSheet("B12").Value = avg
workSheet("C12").Value = max
workSheet("D12").Value = min
$vbLabelText   $csharpLabel

IronXL obsługuje różne typy obramowań, w tym cienkie, średnie, grube, podwójne, kropkowane i kreskowane. Każda strona obramowania może być stylizowana niezależnie.


How Do I Use Excel Formulas in C#?

IronXL ocenia formuły Excela w czasie zapisywania, więc wartości są poprawne, gdy tylko skoroszyt zostanie zapisany:

// Use built-in aggregation functions for ranges
decimal sum = workSheet["A2:A11"].Sum();
decimal avg = workSheet["B2:B11"].Avg();
decimal max = workSheet["C2:C11"].Max();
decimal min = workSheet["D2:D11"].Min();

// Assign calculated values to cells
workSheet["A12"].Value = sum;
workSheet["B12"].Value = avg;
workSheet["C12"].Value = max;
workSheet["D12"].Value = min;

// Or use Excel formulas directly
workSheet["A12"].Formula = "=SUM(A2:A11)";
workSheet["B12"].Formula = "=AVERAGE(B2:B11)";
workSheet["C12"].Formula = "=MAX(C2:C11)";
workSheet["D12"].Formula = "=MIN(D2:D11)";

// Complex formulas with multiple functions
workSheet["E12"].Formula = "=IF(SUM(E2:E11)>50000,\"Over Budget\",\"On Track\")";
workSheet["F12"].Formula = "=SUMIF(F2:F11,\">5000\")";

// Percentage calculations
workSheet["G12"].Formula = "=G11/SUM(G2:G11)*100";
workSheet["G12"].FormatString = "0.00%";

// Ensure all formulas calculate
workSheet.EvaluateAll();
// Use built-in aggregation functions for ranges
decimal sum = workSheet["A2:A11"].Sum();
decimal avg = workSheet["B2:B11"].Avg();
decimal max = workSheet["C2:C11"].Max();
decimal min = workSheet["D2:D11"].Min();

// Assign calculated values to cells
workSheet["A12"].Value = sum;
workSheet["B12"].Value = avg;
workSheet["C12"].Value = max;
workSheet["D12"].Value = min;

// Or use Excel formulas directly
workSheet["A12"].Formula = "=SUM(A2:A11)";
workSheet["B12"].Formula = "=AVERAGE(B2:B11)";
workSheet["C12"].Formula = "=MAX(C2:C11)";
workSheet["D12"].Formula = "=MIN(D2:D11)";

// Complex formulas with multiple functions
workSheet["E12"].Formula = "=IF(SUM(E2:E11)>50000,\"Over Budget\",\"On Track\")";
workSheet["F12"].Formula = "=SUMIF(F2:F11,\">5000\")";

// Percentage calculations
workSheet["G12"].Formula = "=G11/SUM(G2:G11)*100";
workSheet["G12"].FormatString = "0.00%";

// Ensure all formulas calculate
workSheet.EvaluateAll();
' Use built-in aggregation functions for ranges
Dim sum As Decimal = workSheet("A2:A11").Sum()
Dim avg As Decimal = workSheet("B2:B11").Avg()
Dim max As Decimal = workSheet("C2:C11").Max()
Dim min As Decimal = workSheet("D2:D11").Min()

' Assign calculated values to cells
workSheet("A12").Value = sum
workSheet("B12").Value = avg
workSheet("C12").Value = max
workSheet("D12").Value = min

' Or use Excel formulas directly
workSheet("A12").Formula = "=SUM(A2:A11)"
workSheet("B12").Formula = "=AVERAGE(B2:B11)"
workSheet("C12").Formula = "=MAX(C2:C11)"
workSheet("D12").Formula = "=MIN(D2:D11)"

' Complex formulas with multiple functions
workSheet("E12").Formula = "=IF(SUM(E2:E11)>50000,""Over Budget"",""On Track"")"
workSheet("F12").Formula = "=SUMIF(F2:F11,"">5000"")"

' Percentage calculations
workSheet("G12").Formula = "=G11/SUM(G2:G11)*100"
workSheet("G12").FormatString = "0.00%"

' Ensure all formulas calculate
workSheet.EvaluateAll()
$vbLabelText   $csharpLabel

Klasa Range zapewnia metody takie jak Sum, Average, Max oraz Min do szybkich obliczeń. Dla bardziej złożonych scenariuszy, użyj właściwości Formula, aby bezpośrednio ustawić formuły Excela.

PoradyPreferuj wbudowane metody .Sum(), .Avg(), .Max() oraz .Min() w IronXL nad surowymi łańcuchami formuł, pracując z zakresami. Są one typowo bezpieczne i unikają błędów składni formuły w czasie kompilacji.)}


Jak ustawiam właściwości arkusza roboczego i drukowania?

Użyj IronXL, aby chronić poszczególne arkusze, zamrażać wiersze i kolumny oraz ustawiać opcje formatu wydruku.

Jak mogę skonfigurować właściwości arkusza roboczego?

Chroń arkusze i kontroluj opcje wyświetlania:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-11.cs
workSheet.SetPrintArea("A1:L12");
workSheet.PrintSetup.PrintOrientation = IronXL.Printing.PrintOrientation.Landscape;
workSheet.PrintSetup.PaperSize = IronXL.Printing.PaperSize.A4;
workSheet.SetPrintArea("A1:L12")
workSheet.PrintSetup.PrintOrientation = IronXL.Printing.PrintOrientation.Landscape
workSheet.PrintSetup.PaperSize = IronXL.Printing.PaperSize.A4
$vbLabelText   $csharpLabel

Ochrona arkusza zapobiega przypadkowym modyfikacjom, podczas gdy zamrożenie okien utrzymuje ważne wiersze lub kolumny widoczne podczas przewijania.

Zamrożone okienka Rysunek 7 - Zamrożony wiersz nagłówka pozostaje widoczny podczas przewijania

Okno ochrony Excela wymagające hasła do modyfikacji zabezpieczonego arkusza Rysunek 8 - Ochrona hasłem zapobiega nieautoryzowanym edycjom

Jak skonfigurować ustawienia strony i drukowania?

Opcje układu wydruku (orientacja, rozmiar papieru, marginesy, skalowanie, nagłówki, stopki) są dostępne przez WorkSheet.PrintSetup:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-12.cs
workBook.SaveAs("Budget.xlsx");
workBook.SaveAs("Budget.xlsx")
$vbLabelText   $csharpLabel

Klasa IPrintSetup dostarcza kompleksowe opcje konfiguracji wydruku dopasowane do ustawień wydruku Excela.

Podgląd wydruku Excela pokazujący ustawienia orientacji poziomej i rozmiaru papieru A4 Rysunek 9 - Podgląd wydruku z orientacją poziomą i niestandardowymi marginesami


Jak zapisać mój skoroszyt Excel?

Zapisz swój skoroszyt w różnych formatach:

// Save as XLSX (recommended for modern Excel)
workBook.SaveAs("Budget.xlsx");

// Save as XLS for legacy compatibility
workBook.SaveAs("Budget.xls");

// Save as CSV for data exchange
workBook.SaveAsCsv("Budget.csv");

// Save as JSON for web applications
workBook.SaveAsJson("Budget.json");

// Save to stream for web downloads or cloud storage
using (var stream = new MemoryStream())
{
    workBook.SaveAs(stream);
    byte[] excelData = stream.ToArray();
    // Send to client or save to cloud
}

// Save with specific encoding for international characters
workBook.SaveAsCsv("Budget_UTF8.csv", System.Text.Encoding.UTF8);
// Save as XLSX (recommended for modern Excel)
workBook.SaveAs("Budget.xlsx");

// Save as XLS for legacy compatibility
workBook.SaveAs("Budget.xls");

// Save as CSV for data exchange
workBook.SaveAsCsv("Budget.csv");

// Save as JSON for web applications
workBook.SaveAsJson("Budget.json");

// Save to stream for web downloads or cloud storage
using (var stream = new MemoryStream())
{
    workBook.SaveAs(stream);
    byte[] excelData = stream.ToArray();
    // Send to client or save to cloud
}

// Save with specific encoding for international characters
workBook.SaveAsCsv("Budget_UTF8.csv", System.Text.Encoding.UTF8);
' Save as XLSX (recommended for modern Excel)
workBook.SaveAs("Budget.xlsx")

' Save as XLS for legacy compatibility
workBook.SaveAs("Budget.xls")

' Save as CSV for data exchange
workBook.SaveAsCsv("Budget.csv")

' Save as JSON for web applications
workBook.SaveAsJson("Budget.json")

' Save to stream for web downloads or cloud storage
Using stream = New MemoryStream()
	workBook.SaveAs(stream)
	Dim excelData() As Byte = stream.ToArray()
	' Send to client or save to cloud
End Using

' Save with specific encoding for international characters
workBook.SaveAsCsv("Budget_UTF8.csv", System.Text.Encoding.UTF8)
$vbLabelText   $csharpLabel

IronXL obsługuje wiele formatów eksportu, w tym XLSX, XLS, CSV, TSV i JSON. Metoda Save wybiera format na podstawie rozszerzenia pliku.

  • XLSX / XLS: Pełny format Excel z formatowaniem, formułami i wieloma arkuszami
  • CSV: Czysty tekst do wymiany danych, jeden arkusz na plik
  • JSON: Strukturalne dane wyjściowe dla API webowych i linii danych
  • Stream: Wyjście w pamięci, przydatne do pobierania przez sieć lub przechowywania w chmurze

Jak długo faktycznie trwa generowanie?

Uruchomiłem test wydajnościowy generowania na komputerze z Windows 11 (.NET 9.0.7), aby uzyskać konkretne liczby dla skoroszytu o rozmiarze, jaki najczęściej kończy się w produkcji. Narzędzie buduje 10 000-wierszowy, trzykolumnowy XLSX w pamięci i zapisuje go na dysku w jednym wywołaniu SaveAs, zarówno na zimno, jak i na ciepło. Pełny projekt jest dostępny poniżej jako CreateExcelBenchmark sample. Trzy oddzielne uruchomienia procesu dały wyniki blisko tutaj:

Działanie Pierwsze uruchomienie na zimno (świeży proces) Średnia na ciepło po 10 iteracjach
Budowanie 10 000-wierszowego, trzykolumnowego XLSX i SaveAs raz ~570–910 ms ~350 ms (zakres 240–450 ms)

Liczba na zimno jest zdominowana przez ładowanie i rozgrzewanie JIT IronXL. Gdy proces jest gorący, generacja spada do przedziału średnich 300 ms z pewną zmiennością w ramach uruchomień spowodowaną aktywnością w tle. Dla znacznie większych skoroszytów (setki tysięcy wierszy, wiele arkuszy, ciężkie stylizacje), piszę cały skoroszyt w pamięci i wywołuję SaveAs dokładnie raz na końcu. Najczęstszym powodem odwołań "dlaczego mój eksport jest tak wolny?" jest wywoływanie SaveAs wielokrotnie wewnątrz pętli podczas wzrostu skoroszytu: każde zapisanie serializuje cały aktualny stan, więc koszt rośnie przy każdej iteracji.


Typowe pułapki

Kilka rzeczy często sprawia problemy ludziom na tyle, że zasługują na osobną sekcję.

Zapominanie FormatString na daty i waluty

Pułapka formatowania, którą widzę najczęściej: ustawienie .Value na DateTime, ale zapomnienie FormatString. Data jest prawidłowo przechowywana, ale Excel wyświetla ją jako surową liczbę seryjną (45292 oznacza 2024-01-01), dopóki nie zastosujesz formatu, takiego jak "yyyy-MM-dd". Waluta ma identyczny problem: liczba jest poprawna, ale bez "$#,##0.00" wyświetla się jako zwykły dziesiętny. Teraz zapisuję wartość i format na sąsiednich liniach, więc nie mogą się rozłączyć:

var dateCell = sheet["A2"];
dateCell.Value = DateTime.Today;
dateCell.FormatString = "yyyy-MM-dd";

var moneyCell = sheet["B2"];
moneyCell.Value = 1499.95m;
moneyCell.FormatString = "$#,##0.00";
var dateCell = sheet["A2"];
dateCell.Value = DateTime.Today;
dateCell.FormatString = "yyyy-MM-dd";

var moneyCell = sheet["B2"];
moneyCell.Value = 1499.95m;
moneyCell.FormatString = "$#,##0.00";
Dim dateCell = sheet("A2")
dateCell.Value = DateTime.Today
dateCell.FormatString = "yyyy-MM-dd"

Dim moneyCell = sheet("B2")
moneyCell.Value = 1499.95D
moneyCell.FormatString = "$#,##0.00"
$vbLabelText   $csharpLabel

XLS cicho ucina do 65,536 wierszy

To jest wspomniane w sekcji wyboru formatu blisko góry artykułu, ale zasłużenie znajduje się tutaj, ponieważ tryb awarii jest cichy: ExcelFileFormat.XLS ogranicza się do 65 536 rzędów na arkusz, a wiersze poza tym ograniczeniem są pomijane bez wyjątku lub ostrzeżenia. Eksport "udaje się", a twoje dane znikają. Wybierz XLSX dla wszystkiego, co wymaga dużej ilości danych, chyba że system downstream dosłownie nie może go odczytać.

"Excel mówi, że plik jest uszkodzony"

Jeśli wygenerowany plik nie daje się otworzyć lub Excel twierdzi, że jest uszkodzony, przyczyna niemal zawsze jest jedna z dwóch. Albo strumień pliku nie został poprawnie zamknięty, więc bajty na dysku są obcięte; albo zapisałeś do ścieżki, która była jeszcze zablokowana przez poprzednie uruchomienie, i tylko część danych przeszła. Upewnij się, że SaveAs (lub strumień, który go opakowuje) jest w pełni zakończony, zanim cokolwiek innego dotknie pliku, i preferuj blok try-catch wokół każdego MemoryStream lub FileStream, który owijasz do skoroszytu.

Przykładowy projekt dla liczb wyników testów

Jeśli chcesz odtworzyć liczby czasowe z wcześniejszych etapów, narzędzie to mała aplikacja konsolowa .NET 9:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-15.cs
// CreateExcelBenchmark/Program.cs (excerpt)
IronXL.License.LicenseKey = Environment.GetEnvironmentVariable("IRONXL_LICENSE_KEY");

var sw = Stopwatch.StartNew();
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var sheet = workbook.CreateWorkSheet("Data");
sheet["A1"].Value = "Id";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Amount";
for (int i = 0; i < 10_000; i++)
{
    int row = i + 2;
    sheet[$"A{row}"].Value = i + 1;
    sheet[$"B{row}"].Value = $"Item {i + 1}";
    sheet[$"C{row}"].Value = (i + 1) * 1.25m;
}
workbook.SaveAs("Generated.xlsx");
sw.Stop();
Console.WriteLine($"cold: {sw.Elapsed.TotalMilliseconds:F1} ms");
Imports System
Imports System.Diagnostics
Imports IronXL

Module Program
    Sub Main()
        License.LicenseKey = Environment.GetEnvironmentVariable("IRONXL_LICENSE_KEY")

        Dim sw As Stopwatch = Stopwatch.StartNew()
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
        sheet("A1").Value = "Id"
        sheet("B1").Value = "Name"
        sheet("C1").Value = "Amount"
        For i As Integer = 0 To 9999
            Dim row As Integer = i + 2
            sheet($"A{row}").Value = i + 1
            sheet($"B{row}").Value = $"Item {i + 1}"
            sheet($"C{row}").Value = (i + 1) * 1.25D
        Next
        workbook.SaveAs("Generated.xlsx")
        sw.Stop()
        Console.WriteLine($"cold: {sw.Elapsed.TotalMilliseconds:F1} ms")
    End Sub
End Module
$vbLabelText   $csharpLabel

Uruchom to pod dotnet run -c Release i zamień swoje własne liczby wierszy, liczby kolumn lub stylowanie, aby zobaczyć, jak liczby zmieniają się wraz ze skomplikowaniem skoroszytu.


Odnośniki i zasoby

Dokumentacja IronXL API obejmuje każdą klasę i metodę, które ten samouczek pokrywa oraz te, które nie.

Dodatkowe samouczki dla pokrewnych operacji Excel:

Podsumowanie

IronXL.Excel generuje skoroszyty Excel w formatach XLSX, XLS, CSV oraz JSON, bez zależności od Microsoft Office lub Interop. Przepis, który stosuję w każdym projekcie jest taki sam: stworzyć skoroszyt, dodać arkusz, zapisać wartości i formuły, ustawić ciągi formatowania tam, gdzie wyświetlanie ma znaczenie, i zapisać raz na końcu.

Gotowy do używania IronXL w produkcji? Rozpocznij darmowy okres próbny lub zobacz opcje licencjonowania.

Często Zadawane Pytania

Jak mogę tworzyć pliki Excel w C# bez użycia Interop?

Możesz tworzyć pliki Excel bez Interop używając IronXL, który oferuje prosty API: WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX). To podejście działa na każdej platformie .NET bez potrzeby instalacji Microsoft Office.

Jakie platformy wspierają tworzenie plików Excel za pomocą C#?

IronXL wspiera tworzenie plików Excel na .NET 10, .NET 9, .NET 8, .NET Core, .NET Framework 4.6.2+, działających na Windows, macOS, Linux, Docker, Azure i w środowiskach AWS.

Jak zainstalować bibliotekę C# do generowania Excel?

Zainstaluj IronXL przez Menedżera pakietów NuGet w Visual Studio, użyj polecenia PM> Install-Package IronXL.Excel, lub pobierz bezpośrednio z nuget.org.

Jak programowo utworzyć nowy skoroszyt Excel?

Utwórz skoroszyt używając IronXL z WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX), następnie dodaj arkusze używając workbook.CreateWorkSheet("SheetName").

Jak mogę ustawić wartości komórek w arkuszu Excel używając C#?

Ustaw wartości komórek w IronXL używając intuicyjnej składni: worksheet["A1"].Value = "Hello World" lub ustawiaj zakresy: worksheet["A1:A10"].Value = 100.

Czy mogę programowo stosować formatowanie do komórek Excela?

Tak, IronXL wspiera kompleksowe formatowanie w tym kolory tła (cell.Style.SetBackgroundColor("#FF0000")), obramowania, czcionki i formaty liczbowe.

Jak używać formuł Excel w C#?

Stosuj formuły używając właściwości Formula IronXL: worksheet["A1"].Formula = "=SUM(B1:B10)", lub używaj wbudowanych metod jak range.Sum(), range.Avg().

Jak mogę zabezpieczyć arkusz Excel hasłem?

Zabezpieczaj arkusze w IronXL używając worksheet.ProtectSheet("YourPassword") aby zapobiec nieautoryzowanym modyfikacjom.

Jak skonfigurować ustawienia drukowania dla plików Excel?

Ustaw właściwości drukowania używając PrintSetup IronXL: worksheet.PrintSetup.PrintOrientation = PrintOrientation.Landscape i worksheet.SetPrintArea("A1:Z100").

Jak zapisać skoroszyt Excel w różnych formatach?

Zapisuj skoroszyty używając metody SaveAs IronXL: workbook.SaveAs("file.xlsx") dla XLSX, lub używaj SaveAsCsv(), SaveAsJson() dla innych formatów.

Jak wypełnić arkusz Excel danymi z bazy danych?

Użyj IronXL do wypełnienia arkuszy przez pobieranie danych z bazy danych i ustawienie ich w komórkach używając metod jak worksheet["A1"].Value = dataFromDatabase.

Jak mogę zaimplementować zamrażanie okienek w arkuszu Excel używając C#?

Zamrażaj okienka w arkuszach używając IronXL z worksheet.FreezePanes(1, 1) aby zablokować najwyższy wiersz i lewą kolumnę dla łatwiejszej nawigacji.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej
Gotowy, aby rozpocząć?
Nuget Pliki do pobrania 2,150,290 | Wersja: 2026.7 właśnie wydany
Still Scrolling Icon

Wciąż przewijasz?

Chcesz szybkiego dowodu? PM > Install-Package IronXL.Excel
uruchom próbkę zobacz, jak Twoje dane stają się arkuszem.