Jak pracować z plikami Excel w języku C#: Rysunek 1 – Samouczek

Jak pracować ze skoroszytem Excel w języku C#?

1. Utwórz projekt Visual Studio i dodaj pakiet IronXL NuGet.
2. Utwórz plik Excel bez Interop.
3. Dodaj styl do pliku Excel za pomocą IronXL.
4. Odczytaj wartości z Excela i wykonaj obliczenia.
5. Konwersja plików Excel do formatu HTML do użytku w sieci.

Czym jest biblioteka IronXL?

Biblioteka IronXL for .NET to solidna biblioteka, która ułatwia pracę z plikami Excel. Posiada intuicyjny interfejs API, który upraszcza obsługę dokumentów Excel, obsługując różne formaty, takie jak XLS, XLSX i CSV. Ta wszechstronność pozwala na łatwą manipulację wartościami komórek, formułami i formatowaniem. IronXL jest zoptymalizowany pod kątem wydajności, umożliwiając wydajną obsługę dużych plików i złożonych operacji na danych, przy jednoczesnym zapewnieniu efektywnego wykorzystania pamięci. Jego kompatybilność międzyplatformowa zwiększa jego użyteczność w różnych systemach operacyjnych. Oto jego kluczowe cechy i zalety:

Jakie są kluczowe funkcje IronXL?

1. Import i eksport:

   • Import danych: Obsługuje formaty XLS, XLSX, CSV i TSV.
   • Eksport danych: Możliwość eksportowania arkuszy do formatów XLS, XLSX, CSV, TSV i JSON.

2. Manipulacja danymi:

   • System.Data Integration: Praca z arkuszami kalkulacyjnymi jako obiektami DataSet i DataTable.
   • Formuły: Obsługuje formuły programu Excel, które są ponownie obliczane po edycji arkuszy.

3. Stylizacja i formatowanie:

   • Stylizacja komórek: Dostosuj czcionkę, rozmiar, wzór tła, obramowanie, wyrównanie i formaty liczb.
   • Zakresy: Intuicyjne ustawianie zakresów za pomocą składni WorkSheet["A1:B10"].

4. Bezpieczeństwo:

   • Szyfrowanie: Szyfruj i deszyfruj pliki XLSX, XLSM i XLTX za pomocą haseł.
5. Kompatybilność międzyplatformowa:
   • Współpracuje z .NET Framework, .NET Core, .NET Standard i Azure.
   • Kompatybilny z systemami Windows, macOS, Linux, Docker i AWS.

Dłączego warto wybrać bibliotekę IronXL zamiast innych bibliotek Excel?

1. Nie wymaga pakietu Microsoft Office: IronXL nie wymaga instalacji pakietu Microsoft Office, dzięki czemu jest lekki i łatwy we wdrożeniu.
2. Łatwość użytkowania: API jest intuicyjne i łatwe w użyciu, co pozwala programistom na szybką integrację funkcji programu Excel z ich aplikacjami.
3. Wydajność: IronXL jest zoptymalizowany pod kątem wydajności, zapewniając szybkie i sprawne przetwarzanie dużych plików Excel.
4. Wszechstronność: Nadaje się do szerokiego zakresu zastosowań, w tym rozwiązań internetowych, stacjonarnych i opartych na chmurze.
5. Kompleksowa dokumentacja: Dostępna jest obszerna dokumentacja i przykłady, co ułatwia programistom rozpoczęcie pracy i znalezienie rozwiązań typowych problemów.

Jak rozpocząć pracę z IronXL?

Aby korzystać z IronXL w projektach .NET, należy upewnić się, że środowisko programistyczne spełnia następujące wymagania wstępne:

dotnet add package IronXl.Excel --version 2024.8.5

dotnet add package IronXl.Excel --version 2024.8.5

Jak utworzyć swój pierwszy plik Excel za pomocą IronXL?

Stwórzmy projekt w Visual Studio i dodajmy bibliotekę IronXL, aby rozpocząć pracę z plikiem Excel.

Jak utworzyć projekt Visual Studio i dodać IronXL?

Otwórz program Microsoft Visual Studio i wybierz opcję "Utwórz nowy projekt", aby rozpocząć pracę.

Wybierz wybrany szablon projektu. Tutaj dla uproszczenia wybraliśmy aplikację konsolową.

Teraz wprowadź nazwę projektu i lokalizację projektu.

Wybierz preferowaną wersję .NET Framework. Wybraliśmy najnowszą wersję dostępną na naszym komputerze.

Po kliknięciu przycisku Utwórz projekt zostanie utworzony i będzie gotowy do użycia. Otwórz Eksplorator rozwiązań, aby sprawdzić pliki projektu.

Teraz zainstalujmy bibliotekę IronXL z menedżera pakietów NuGet, tak jak pokazano powyżej.

Jak utworzyć plik Excel bez Interop?

Teraz stwórzmy plik Excel bez użycia biblioteki Microsoft Interop. IronXL zapewnia prosty i intuicyjny sposób programowego tworzenia arkuszy kalkulacyjnych.

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create new Excel WorkBook Object
			Dim workBook As WorkBook = WorkBook.Create()
			' Create WorkSheet
			Dim workSheet As WorkSheet = workBook.CreateWorkSheet("newXlDemo")
			' Add data in new worksheet
			workSheet("A1").Value = "IronXL is the best Excel library"
			' Save the Excel file as XLSX
			workBook.SaveAs("myIronXlDemo.xlsx")
		End Sub
	End Class
End Namespace

Wyjaśnienie kodu

1. Dodajemy przestrzeń nazw IronXL, aby rozpocząć pracę z biblioteką IronXL.
2. Utwórz obiekt Excel z WorkBook.Create(), aby utworzyć plik XLSX.
3. Wywołaj metodę CreateWorkSheet, aby utworzyć arkusz w skoroszycie.
4. Dodaj wartości do komórek za pomocą workSheet["A1"].Value.
5. Zapisz plik Excel używając workBook.SaveAs, podając nazwę pliku.

Plik wyjściowy w formacie Excel

// Save as different Excel formats
workBook.SaveAs("file.xlsx"); // Excel 2007+ format
workBook.SaveAs("file.xls");  // Excel 97-2003 format
workBook.SaveAs("file.xlsm"); // Excel with macros

// Export to other formats
workBook.SaveAsCsv("file.csv", ",");  // CSV with comma delimiter
workBook.SaveAsJson("file.json");     // JSON format
workBook.SaveAsXml("file.xml");       // XML format

// Save as different Excel formats
workBook.SaveAs("file.xlsx"); // Excel 2007+ format
workBook.SaveAs("file.xls");  // Excel 97-2003 format
workBook.SaveAs("file.xlsm"); // Excel with macros

// Export to other formats
workBook.SaveAsCsv("file.csv", ",");  // CSV with comma delimiter
workBook.SaveAsJson("file.json");     // JSON format
workBook.SaveAsXml("file.xml");       // XML format

' Save as different Excel formats
workBook.SaveAs("file.xlsx") ' Excel 2007+ format
workBook.SaveAs("file.xls")  ' Excel 97-2003 format
workBook.SaveAs("file.xlsm") ' Excel with macros

' Export to other formats
workBook.SaveAsCsv("file.csv", ",")  ' CSV with comma delimiter
workBook.SaveAsJson("file.json")     ' JSON format
workBook.SaveAsXml("file.xml")       ' XML format

try 
{
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("Demo");
    workSheet["A1"].Value = "Sample Data";

    // Check if directory exists
    string directory = @"C:\ExcelFiles\";
    if (!Directory.Exists(directory))
    {
        Directory.CreateDirectory(directory);
    }

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"));
}
catch (Exception ex)
{
    Console.WriteLine($"Error creating Excel file: {ex.Message}");
}

try 
{
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("Demo");
    workSheet["A1"].Value = "Sample Data";

    // Check if directory exists
    string directory = @"C:\ExcelFiles\";
    if (!Directory.Exists(directory))
    {
        Directory.CreateDirectory(directory);
    }

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"));
}
catch (Exception ex)
{
    Console.WriteLine($"Error creating Excel file: {ex.Message}");
}

Imports System
Imports System.IO

Try
    Dim workBook As WorkBook = WorkBook.Create()
    Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Demo")
    workSheet("A1").Value = "Sample Data"

    ' Check if directory exists
    Dim directory As String = "C:\ExcelFiles\"
    If Not Directory.Exists(directory) Then
        Directory.CreateDirectory(directory)
    End If

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"))
Catch ex As Exception
    Console.WriteLine($"Error creating Excel file: {ex.Message}")
End Try

Jak dodać stylizację do plików Excel za pomocą IronXL?

Zobaczmy teraz, jak dodawać style do komórek programu Excel. IronXL oferuje szerokie możliwości stylizacji, pozwalające tworzyć profesjonalnie wyglądające arkusze kalkulacyjne.

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
    Public Class Program
        Public Shared Sub Main()
            ' Create a new workbook
            Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            ' Create a new worksheet
            Dim workSheet As WorkSheet = workBook.CreateWorkSheet("StyledSheet")
            ' Add multiple values to cells
            workSheet("A1").Value = "This Styled Text with Awesome IronXL library"
            workSheet("A2").Value = 999999
            ' Apply styles to cells
            workSheet("A1").Style.Font.Bold = True
            workSheet("A1").Style.Font.Italic = True
            workSheet("A1").Style.Font.Height = 14
            workSheet("A1").Style.Font.Color = "#FF0000" ' Red color
            workSheet("A2").Style.BottomBorder.Type = IronXl.Styles.BorderType.Double
            workSheet("A2").Style.BottomBorder.SetColor("#00FF00") ' Green color
            ' Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx")
        End Sub
    End Class
End Namespace

Wyjaśnienie kodu

1. Utwórz plik Excel przy użyciu WorkBook.Create.
2. Utwórz arkusz roboczy przy użyciu workBook.CreateWorkSheet.
3. Dodaj wartości do komórek za pomocą workSheet["A1"].Value.
4. Dodaj style do komórek, używając właściwości takich jak workSheet["A1"].Style.Font.Bold.
5. Zapisz skoroszyt, używając workBook.SaveAs.

Plik wyjściowy w formacie Excel

// Apply styles to a range
var range = workSheet["A1:D10"];
foreach (var cell in range)
{
    cell.Style.Font.Bold = true;
    cell.Style.Font.Color = "#0000FF"; // Blue
    cell.Style.SetBackgroundColor("#FFFF00"); // Yellow background
}

// Apply styles to a range
var range = workSheet["A1:D10"];
foreach (var cell in range)
{
    cell.Style.Font.Bold = true;
    cell.Style.Font.Color = "#0000FF"; // Blue
    cell.Style.SetBackgroundColor("#FFFF00"); // Yellow background
}

' Apply styles to a range
Dim range = workSheet("A1:D10")
For Each cell In range
    cell.Style.Font.Bold = True
    cell.Style.Font.Color = "#0000FF" ' Blue
    cell.Style.SetBackgroundColor("#FFFF00") ' Yellow background
Next

// Add conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(
    ComparisonOperator.GreaterThan, "100");
rule.FontFormatting.Bold = true;
rule.FontFormatting.FontColor = "#FF0000"; // Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule);

// Add conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(
    ComparisonOperator.GreaterThan, "100");
rule.FontFormatting.Bold = true;
rule.FontFormatting.FontColor = "#FF0000"; // Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule);

' Add conditional formatting rule
Dim rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.GreaterThan, "100")
rule.FontFormatting.Bold = True
rule.FontFormatting.FontColor = "#FF0000" ' Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule)

Jak odczytać wartości z Excela i wykonać obliczenia?

Zobaczmy teraz, jak odczytywać pliki Excel za pomocą IronXL i wykonywać obliczenia. IronXL obsługuje różne funkcje matematyczne do analizy danych.

using IronXL;
using System;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
    }
}

using IronXL;
using System;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronXL
Imports System

Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ReadData()
			' Load the Excel worksheet
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			' Select the first worksheet
			Dim workSheet As WorkSheet = workBook.WorkSheets(0)
			' Read a specific cell value
			Dim cellValue As Integer = workSheet("A2").IntValue
			Console.WriteLine($"Value in A2: {cellValue}")
			' Read a range of cells
			For Each cell In workSheet("A1:H10")
				Console.Write($"{cell.Text}" & vbTab)
				If cell.AddressString.Contains("H") Then
					Console.WriteLine()
				End If
			Next cell
			' Calculate aggregate values
			Dim sum As Decimal = workSheet("F2:F10").Sum()
			Console.WriteLine($"Sum of F2:F10: {sum}")
		End Sub
	End Class
End Namespace

Wyjaśnienie kodu

1. Załaduj plik Excel za pomocą WorkBook.Load.
2. Otwórz pierwszy arkusz w skoroszycie.
3. Odczytaj wartość konkretnej komórki i wyświetl ją za pomocą Console.WriteLine.
4. Przejrzyj zakres komórek i PRINT każdą wartość. PRINT nowe wiersze po kolumnie H.
5. Oblicz sumę wartości w zakresie F2:F10 i PRINT ją.

Plik wejściowy Excel

Wynik

// Different ways to read cell values
string textValue = workSheet["A1"].StringValue;
int intValue = workSheet["B1"].IntValue;
decimal decimalValue = workSheet["C1"].DecimalValue;
double doubleValue = workSheet["D1"].DoubleValue;
DateTime dateValue = workSheet["E1"].DateTimeValue;
bool boolValue = workSheet["F1"].BoolValue;

// Read formula results
string formulaResult = workSheet["G1"].FormattedCellValue;

// Different ways to read cell values
string textValue = workSheet["A1"].StringValue;
int intValue = workSheet["B1"].IntValue;
decimal decimalValue = workSheet["C1"].DecimalValue;
double doubleValue = workSheet["D1"].DoubleValue;
DateTime dateValue = workSheet["E1"].DateTimeValue;
bool boolValue = workSheet["F1"].BoolValue;

// Read formula results
string formulaResult = workSheet["G1"].FormattedCellValue;

' Different ways to read cell values
Dim textValue As String = workSheet("A1").StringValue
Dim intValue As Integer = workSheet("B1").IntValue
Dim decimalValue As Decimal = workSheet("C1").DecimalValue
Dim doubleValue As Double = workSheet("D1").DoubleValue
Dim dateValue As DateTime = workSheet("E1").DateTimeValue
Dim boolValue As Boolean = workSheet("F1").BoolValue

' Read formula results
Dim formulaResult As String = workSheet("G1").FormattedCellValue

// Check if cell is empty
if (workSheet["A1"].IsEmpty)
{
    Console.WriteLine("Cell A1 is empty");
}

// Use null-coalescing for safe value reading
string value = workSheet["A1"].StringValue ?? "Default Value";

// Check for specific content types
if (workSheet["B1"].IsNumeric)
{
    decimal numValue = workSheet["B1"].DecimalValue;
}

// Check if cell is empty
if (workSheet["A1"].IsEmpty)
{
    Console.WriteLine("Cell A1 is empty");
}

// Use null-coalescing for safe value reading
string value = workSheet["A1"].StringValue ?? "Default Value";

// Check for specific content types
if (workSheet["B1"].IsNumeric)
{
    decimal numValue = workSheet["B1"].DecimalValue;
}

' Check if cell is empty
If workSheet("A1").IsEmpty Then
    Console.WriteLine("Cell A1 is empty")
End If

' Use null-coalescing for safe value reading
Dim value As String = If(workSheet("A1").StringValue, "Default Value")

' Check for specific content types
If workSheet("B1").IsNumeric Then
    Dim numValue As Decimal = workSheet("B1").DecimalValue
End If

// Available aggregate functions
decimal sum = workSheet["A1:A10"].Sum();
decimal avg = workSheet["A1:A10"].Avg();
decimal min = workSheet["A1:A10"].Min();
decimal max = workSheet["A1:A10"].Max();
int count = workSheet["A1:A10"].Count();

// Available aggregate functions
decimal sum = workSheet["A1:A10"].Sum();
decimal avg = workSheet["A1:A10"].Avg();
decimal min = workSheet["A1:A10"].Min();
decimal max = workSheet["A1:A10"].Max();
int count = workSheet["A1:A10"].Count();

' Available aggregate functions
Dim sum As Decimal = workSheet("A1:A10").Sum()
Dim avg As Decimal = workSheet("A1:A10").Avg()
Dim min As Decimal = workSheet("A1:A10").Min()
Dim max As Decimal = workSheet("A1:A10").Max()
Dim count As Integer = workSheet("A1:A10").Count()

Jak przekonwertować plik Excel na HTML do użytku w sieci?

Zobaczmy, jak przekonwertować plik Excel na HTML do użytku w sieci. Jest to szczególnie przydatne do wyświetlania danych z Excela w aplikacjach internetowych.

using IronXL;
using IronXl.Options;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            var options = new HtmlExportOptions()
            {
                // Set row/column numbers visible in HTML document
                OutputRowNumbers = true,
                OutputColumnHeaders = true,
                // Set hidden rows/columns visible in HTML document
                OutputHiddenRows = true,
                OutputHiddenColumns = true,
                // Set leading spaces as non-breaking
                OutputLeadingSpacesAsNonBreaking = true
            };
            // Export workbook to the HTML file
            workBook.ExportToHtml("workBook.html", options);
        }
    }
}

using IronXL;
using IronXl.Options;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            var options = new HtmlExportOptions()
            {
                // Set row/column numbers visible in HTML document
                OutputRowNumbers = true,
                OutputColumnHeaders = true,
                // Set hidden rows/columns visible in HTML document
                OutputHiddenRows = true,
                OutputHiddenColumns = true,
                // Set leading spaces as non-breaking
                OutputLeadingSpacesAsNonBreaking = true
            };
            // Export workbook to the HTML file
            workBook.ExportToHtml("workBook.html", options);
        }
    }
}

Imports IronXL
Imports IronXl.Options

Namespace WorkingWithIronXL

    Friend Class IronXlDemo

        Public Shared Sub ConvertToHtml()
            Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
            Dim options As New HtmlExportOptions() With {
                .OutputRowNumbers = True,
                .OutputColumnHeaders = True,
                .OutputHiddenRows = True,
                .OutputHiddenColumns = True,
                .OutputLeadingSpacesAsNonBreaking = True
            }
            workBook.ExportToHtml("workBook.html", options)
        End Sub

    End Class

End Namespace

Wyjaśnienie kodu

1. Załaduj plik Excel przy użyciu metody Load.
2. Ustaw opcje konwersji HTML za pomocą HtmlExportOptions.
3. Użyj metody ExportToHtml, aby przekonwertować i zapisać jako HTML.

Dane wejściowe

Wynik

var htmlOptions = new HtmlExportOptions()
{
    // Table formatting options
    OutputRowNumbers = true,
    OutputColumnHeaders = true,

    // Visibility options  
    OutputHiddenRows = false,
    OutputHiddenColumns = false,

    // Formatting preservation
    OutputLeadingSpacesAsNonBreaking = true,

    // Custom CSS class
    TableCssClass = "excel-table"
};

var htmlOptions = new HtmlExportOptions()
{
    // Table formatting options
    OutputRowNumbers = true,
    OutputColumnHeaders = true,

    // Visibility options  
    OutputHiddenRows = false,
    OutputHiddenColumns = false,

    // Formatting preservation
    OutputLeadingSpacesAsNonBreaking = true,

    // Custom CSS class
    TableCssClass = "excel-table"
};

Dim htmlOptions As New HtmlExportOptions() With {
    .OutputRowNumbers = True,
    .OutputColumnHeaders = True,
    .OutputHiddenRows = False,
    .OutputHiddenColumns = False,
    .OutputLeadingSpacesAsNonBreaking = True,
    .TableCssClass = "excel-table"
}

// Export with inline CSS styles
workBook.ExportToHtml("styled.html", new HtmlExportOptions
{
    OutputRowNumbers = false,
    OutputColumnHeaders = true,
    // Preserves cell styles as inline CSS
    PreserveStyles = true
});

// Export with inline CSS styles
workBook.ExportToHtml("styled.html", new HtmlExportOptions
{
    OutputRowNumbers = false,
    OutputColumnHeaders = true,
    // Preserves cell styles as inline CSS
    PreserveStyles = true
});

' Export with inline CSS styles
workBook.ExportToHtml("styled.html", New HtmlExportOptions With {
    .OutputRowNumbers = False,
    .OutputColumnHeaders = True,
    ' Preserves cell styles as inline CSS
    .PreserveStyles = True
})

// Export specific worksheet
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");
sheet.SaveAsHtml("sheet1.html");

// Export multiple specific sheets
foreach (var sheetName in new[] { "Sheet1", "Sheet3" })
{
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html");
}

// Export specific worksheet
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");
sheet.SaveAsHtml("sheet1.html");

// Export multiple specific sheets
foreach (var sheetName in new[] { "Sheet1", "Sheet3" })
{
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html");
}

' Export specific worksheet
Dim sheet As WorkSheet = workBook.GetWorkSheet("Sheet1")
sheet.SaveAsHtml("sheet1.html")

' Export multiple specific sheets
For Each sheetName As String In {"Sheet1", "Sheet3"}
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html")
Next

Jakie są rzeczywiste przykłady zastosowań IronXL?

IronXL to wszechstronna biblioteka .NET o szerokim zakresie praktycznych zastosowań, w tym:

1. Raportowanie biznesowe:

• Automatyzacja okresowych raportów, takich jak podsumowania sprzedaży i sprawozdania finansowe.
• Tworzenie niestandardowych pulpitów nawigacyjnych na podstawie różnych źródeł danych.
• Eksportowanie danych do programu Excel na potrzeby prezentacji dla interesariuszy.

2. Analiza danych:

• Przetwarzanie dużych zbiorów danych na potrzeby analizy statystycznej i transformacji.
• Eksportowanie przeanalizowanych danych do wglądu dla interesariuszy.
• Wykorzystanie funkcji agregujących do szybkiego uzyskania wglądu w dane.

3. Zarządzanie zapasami:

• Zarządzanie zapasami produktów wraz z informacjami o stanach magazynowych i dostawcach.
• Generowanie raportów dotyczących zasobów w celu śledzenia trendów.
• Importowanie danych CSV od dostawców.

4. Zarządzanie relacjami z klientami (CRM):

• Eksportowanie danych klientów w celu przeprowadzenia szczegółowej analizy.
• Aktualizacja rekordów CRM poprzez import zmodyfikowanych danych.
• Tworzenie raportów segmentacyjnych przy użyciu formatowania warunkówego.

5. Instytucje edukacyjne:

• Tworzenie dzienników ocen i rejestrów obecności uczniów.
• Generowanie wyników egzaminów i analiza wyników.
• Wykorzystanie formuł do automatycznego obliczania ocen.

6. Usługi finansowe:

• Automatyzacja modeli finansowych, budżetów i prognoz.
• Konsolidacja danych finansowych w celu sporządzenia kompleksowych raportów.
• Tworzenie wykresów do analizy wizualnej.

7. Zasoby ludzkie:

• Zarządzanie danymi pracowników, w tym listami płac i ocenami.
• Generowanie raportów dotyczących wskaźników kadrowych i danych demograficznych.
• Ochrona wrażliwych danych za pomocą szyfrowania hasłem.

8. Zarządzanie projektami:

• Śledzenie harmonogramów projektów i alokacji zasobów.
• Tworzenie wykresów Gantta i narzędzi do zarządzania projektami.
• Wykorzystanie nazwanych zakresów do zarządzania formułami.

9. E-commerce:

• Eksportowanie szczegółów zamówień, informacji o klientach i danych dotyczących sprzedaży z platform e-commerce do programu Excel.
• Analiza trendów sprzedaży, zachowań klientów i wyników produktów.

10. Opieka zdrowotna:

• Zarządzanie dokumentacją pacjentów i harmonogramami wizyt.
• Analiza danych dotyczących opieki zdrowotnej w celu poprawy jakości opieki nad pacjentami.
• Zabezpieczanie danych pacjentów za pomocą ochrony arkuszy.

Jak uzyskać licencję IronXL do użytku produkcyjnego?

IronXL to biblioteka Enterprise dla przedsiębiorstw firmy Iron Software. Do działania wymaga licencji. Możesz pobrać Licencję Trial, używając swojego adresu e-mail, tutaj. Po przesłaniu licencja zostanie dostarczona na Twój adres e-mail. Umieść tę licencję na początku swojego kodu, przed użyciem IronXL:

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here"

// Method 1: In code
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY";

// Method 2: Using app.config or web.config
// Add to configuration file:
// <appSettings>
//   <add key="IronXl.LicenseKey" value="YOUR-LICENSE-KEY"/>
// </appSettings>

// Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY");

// Method 1: In code
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY";

// Method 2: Using app.config or web.config
// Add to configuration file:
// <appSettings>
//   <add key="IronXl.LicenseKey" value="YOUR-LICENSE-KEY"/>
// </appSettings>

// Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY");

' Method 1: In code
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY"

' Method 2: Using app.config or web.config
' Add to configuration file:
' <appSettings>
'   <add key="IronXl.LicenseKey" value="YOUR-LICENSE-KEY"/>
' </appSettings>

' Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY")

Czego dowiedzieliśmy się o pracy z plikami Excel w języku C#?

IronXL to potężna biblioteka .NET do tworzenia, odczytu i edycji plików Excel, oferująca intuicyjny interfejs API, który upraszcza pracę z dokumentami Excel. Obsługuje wiele formatów, w tym XLS, XLSX i CSV, dzięki czemu jest wszechstronny i nadaje się do różnych zastosowań. IronXL umożliwia łatwą manipulację wartościami komórek, formułami i formatowaniem oraz jest zoptymalizowany pod kątem wydajności, efektywnie obsługując duże pliki i złożone operacje. Zarządzanie pamięcią zapewnia responsywność aplikacji, a kompatybilność międzyplatformowa sprawia, że jest to cenne narzędzie dla programistów korzystających z różnych systemów operacyjnych.

Niezależnie od tego, czy tworzysz aplikacje internetowe, oprogramowanie desktopowe czy usługi w chmurze, IronXL zapewnia narzędzia niezbędne do efektywnej pracy z plikami Excel w języku C#. Aby zapoznać się z bardziej zaawansowanymi funkcjami, przejrzyj pełną dokumentację i zapoznaj się z obszernymi przykładami kodu.

Najważniejsze wnioski:

• Nie wymaga instalacji pakietu Microsoft Office
• Obsługa wielu platform: Windows, Linux, macOS
• Kompleksowe opcje stylizacji i formatowania
• Obsługa formuł i obliczeń
• Funkcje bezpieczeństwa, w tym ochrona hasłem
• Łatwy eksport i import danych
• Doskonała optymalizacja wydajności

Bądź na bieżąco z najnowszymi funkcjami i ulepszeniami, sprawdzając dziennik zmian i kamieńie milowe dotyczące ciągłego udoskonalania IronXL.