So arbeiten Sie mit Excel-Dateien in C#: Abbildung 1 – Tutorial

Wie kann ich in C# mit Excel-Arbeitsmappen arbeiten?

1. Erstellen Sie ein Visual Studio-Projekt und fügen Sie das IronXL NuGet-Paket hinzu.
2. Erstellen Sie eine Excel-Datei ohne Interop.
3. Fügen Sie Stil zu Excel-Dateien mit IronXL hinzu.
4. Lesen Sie Werte aus Excel und berechnen Sie.
5. Konvertieren Sie Excel in HTML für die Webverwendung.

Was ist die IronXL Bibliothek?

IronXL ist eine robuste Bibliothek for .NET , die die Arbeit mit Excel-Dateien vereinfacht. Es verfügt über eine intuitive API , die die Bearbeitung von Excel-Dokumenten vereinfacht und verschiedene Formate wie XLS, XLSX und CSV unterstützt. Diese Vielseitigkeit ermöglicht die einfache Bearbeitung von Zellwerten, Formeln und Formatierungen. IronXL ist auf Leistung optimiert und kann große Dateien und komplexe Datenoperationen effizient verarbeiten, während gleichzeitig eine effiziente Speichernutzung gewährleistet wird. Die plattformübergreifende Kompatibilität erhöht den Nutzen auf verschiedenen Betriebssystemen. Hier sind die wichtigsten Merkmale und Vorteile:

Was sind die wichtigsten Merkmale von IronXL?

1. Import und Export:

   • Importdaten: Unterstützt die Formate XLS, XLSX, CSV und TSV .
   • Datenexport: Arbeitsblätter können in die Formate XLS, XLSX, CSV, TSV und JSON exportiert werden .

2. Datenmanipulation:

   • System.Data Integration: Arbeiten mit Tabellenkalkulationen als DataSet und DataTable Objekte .
   • Formeln: Unterstützt Excel-Formeln , die bei der Bearbeitung von Tabellenblättern neu berechnet werden.

3. Stil und Formatierung:

   • Zellenstyling: Schriftart, Größe , Hintergrundmuster , Rahmen, Ausrichtung und Zahlenformate anpassen.
   • Bereiche: Intuitive Bereichseinstellung mit der Syntax WorkSheet["A1:B10"].

4. Sicherheit:

   • Verschlüsselung: Verschlüsseln und entschlüsseln Sie XLSX-, XLSM- und XLTX-Dateien mit Passwörtern.
5. Plattformübergreifende Kompatibilität:
   • Funktioniert mit .NET Framework, .NET Core, .NET Standard und Azure .
   • Kompatibel mit Windows, macOS , Linux , Docker und AWS .

Warum sollte ich IronXL anderen Excel-Bibliotheken vorziehen?

1. Microsoft Office nicht erforderlich: IronXL benötigt keine Installation von Microsoft Office und ist daher ressourcenschonend und einfach einzusetzen.
2. Benutzerfreundlichkeit: Die API ist intuitiv und einfach zu bedienen, sodass Entwickler die Excel-Funktionalität schnell in ihre Anwendungen integrieren können.
3. Leistung: IronXL ist auf Leistung optimiert und gewährleistet eine schnelle und effiziente Verarbeitung großer Excel-Dateien.
4. Vielseitigkeit: Geeignet für eine breite Palette von Anwendungen, einschließlich web-, desktop- und cloudbasierter Lösungen.
5. Umfassende Dokumentation: Es stehen umfangreiche Dokumentationen und Beispiele zur Verfügung, die es Entwicklern erleichtern, loszulegen und Lösungen für häufig auftretende Probleme zu finden.

Wie fange ich mit IronXL an?

Um IronXL in Ihren .NET-Projekten zu verwenden, müssen Sie sicherstellen, dass Ihre Entwicklungsumgebung die folgenden Voraussetzungen erfüllt:

dotnet add package IronXL.Excel --version 2024.8.5

dotnet add package IronXL.Excel --version 2024.8.5

Wie erstelle ich meine erste Excel-Datei mit IronXL?

Wir entwickeln ein Visual Studio-Projekt und fügen die IronXL -Bibliothek hinzu, um mit der Arbeit an einer Excel-Datei zu beginnen.

Wie erstelle ich ein Visual Studio-Projekt und füge IronXL hinzu?

Öffnen Sie Microsoft Visual Studio und wählen Sie "Neues Projekt erstellen", um zu beginnen.

Wählen Sie die gewünschte Projektvorlage. Hier haben wir aus Gründen der Einfachheit die Konsolenanwendung ausgewählt.

Geben Sie nun den Projektnamen und den Speicherort für das Projekt ein.

Wählen Sie die von Ihnen bevorzugte .NET Framework-Version aus. Wir haben die neueste Version für unsere Maschine ausgewählt.

Sobald Sie auf die Schaltfläche "Erstellen" klicken, wird das Projekt erstellt und ist einsatzbereit. Öffnen Sie den Lösungsexplorer, um die Projektdateien zu überprüfen.

Installieren wir nun die IronXL-Bibliothek aus dem oben gezeigten NuGet-Paketmanager.

Wie erstelle ich eine Excel-Datei ohne Interop?

Nun erstellen wir eine Excel-Datei ohne die Microsoft Interop-Bibliothek. IronXL bietet eine einfache und intuitive Möglichkeit, Tabellenkalkulationen programmatisch zu erstellen .

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

Code-Erklärung

1. Wir fügen den IronXL-Namespace hinzu, um mit der Bibliothek zu arbeiten.
2. Erstellen Sie ein Excel-Objekt mit WorkBook.Create(), um eine XLSX-Datei zu erstellen.
3. Rufen Sie die Methode CreateWorkSheet auf, um ein Arbeitsblatt innerhalb der Arbeitsmappe zu erstellen.
4. Fügen Sie Zellen Werte mit workSheet["A1"].Value hinzu.
5. Speichern Sie die Excel-Datei mit workBook.SaveAs, indem Sie einen Dateinamen angeben.

Excel-Ausgabedatei

// 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

Wie kann ich Excel-Dateien mit IronXL formatieren?

Sehen wir uns nun an, wie man Stile zu Excel-Zellen hinzufügt. IronXL bietet umfassende Gestaltungsmöglichkeiten für die Erstellung professionell aussehender Tabellenkalkulationen.

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

Code-Erklärung

1. Erstellen Sie eine Excel-Datei mit WorkBook.Create.
2. Erstellen Sie ein Arbeitsblatt mit workBook.CreateWorkSheet.
3. Fügen Sie Zellen Werte mit workSheet["A1"].Value hinzu.
4. Fügen Sie Zellen Stile hinzu, indem Sie Eigenschaften wie workSheet["A1"].Style.Font.Bold verwenden.
5. Speichern Sie die Arbeitsmappe mit workBook.SaveAs.

Excel-Ausgabedatei

// 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)

Wie lese ich Werte aus Excel ein und berechne sie?

Schauen wir uns nun an, wie man mit IronXL Excel-Dateien liest und Berechnungen durchführt. IronXL unterstützt verschiedene mathematische Funktionen zur Datenanalyse.

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

Code-Erklärung

1. Laden Sie eine Excel-Datei mit WorkBook.Load.
2. Greifen Sie auf das erste Arbeitsblatt in der Arbeitsmappe zu.
3. Lies den Wert einer bestimmten Zelle und zeige ihn mit Console.WriteLine an.
4. Durchlaufe einen Bereich von Zellen und gib jeden Wert aus. Nach Spalte H eine neue Zeile ausgeben.
5. Berechne die Summe der Werte im Bereich F2:F10 und gib sie aus.

Eingabe-Excel

Ausgabe

// 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()

Wie konvertiere ich Excel-Tabellen in HTML für die Webnutzung?

Schauen wir uns an, wie man Excel-Dateien für die Webnutzung in HTML konvertiert . Dies ist besonders nützlich für die Darstellung von Excel-Daten in Webanwendungen.

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 = New HtmlExportOptions() With {
				.OutputRowNumbers = True,
				.OutputColumnHeaders = True,
				.OutputHiddenRows = True,
				.OutputHiddenColumns = True,
				.OutputLeadingSpacesAsNonBreaking = True
			}
			' Export workbook to the HTML file
			workBook.ExportToHtml("workBook.html", options)
		End Sub
	End Class
End Namespace

Code-Erklärung

1. Laden Sie die Excel-Datei mit der Methode Load.
2. Optionen für die HTML-Konvertierung mit HtmlExportOptions festlegen.
3. Verwenden Sie die Methode ExportToHtml, um die Konvertierung durchzuführen und die Datei als HTML zu speichern.

Eingabe

Ausgabe

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

Was sind die realen Anwendungsfälle für IronXL?

IronXL ist eine vielseitige .NET-Bibliothek mit einer Vielzahl realer Anwendungen, darunter:

1. Geschäftsberichte:

• Automatisierung periodischer Berichte wie Umsatzübersichten und Finanzberichte.
• Erstellung benutzerdefinierter Dashboards aus verschiedenen Datenquellen.
• Datenexport nach Excel für Präsentationen vor Stakeholdern.

2. Datenanalyse:

• Verarbeitung großer Datensätze für statistische Analysen und Transformationen.
• Export der analysierten Daten zur Prüfung durch die Interessengruppen.
• Verwendung von Aggregatfunktionen für schnelle Erkenntnisse.

3. Bestandsverwaltung:

• Verwaltung von Produktbeständen mit Lagerbestandsinformationen und Lieferantendetails.
• Erstellung von Bestandsberichten zur Verfolgung von Trends.
• Import von CSV-Daten von Lieferanten.

4. Kundenbeziehungsmanagement (CRM):

• Export von Kundendaten zur detaillierten Analyse.
• Aktualisierung von CRM-Datensätzen durch Importieren geänderter Daten .
• Erstellung von Segmentierungsberichten mithilfe bedingter Formatierung .

5. Bildungseinrichtungen:

• Erstellung von Schülernotenbüchern und Anwesenheitslisten.
• Generierung von Prüfungsergebnissen und Leistungsanalysen.
• Verwendung von Formeln zur automatischen Notenberechnung.

6. Finanzdienstleistungen:

• Automatisierung von Finanzmodellen, Budgets und Prognosen.
• Konsolidierung von Finanzdaten für eine umfassende Berichterstattung.
• Erstellung von Diagrammen zur visuellen Analyse.

7. Personalwesen:

• Verwaltung von Mitarbeiterdaten einschließlich Gehaltsabrechnung und Leistungsbeurteilungen.
• Erstellung von Berichten zu HR-Kennzahlen und demografischen Daten.
• Schutz sensibler Daten durch Passwortverschlüsselung.

8. Projektmanagement:

• Überwachung von Projektzeitplänen und Ressourcenzuweisung.
• Erstellung von Gantt-Diagrammen und Projektmanagement-Tools.
• Verwendung benannter Bereiche für die Formelverwaltung.

9. E-Commerce:

• Export von Bestelldetails, Kundeninformationen und Verkaufsdaten von E-Commerce-Plattformen in Excel.
• Analyse von Verkaufstrends, Kundenverhalten und Produktleistung.

10. Gesundheitswesen:

• Verwaltung von Patientenakten und Terminplänen.
• Analyse von Gesundheitsdaten zur Verbesserung der Patientenversorgung.
• Sicherung von Patientendaten durch Tabellenkalkulationsschutz.

Wie erhalte ich eine Lizenz für IronXL zur Produktion?

IronXL ist eine Enterprise Bibliothek von Iron Software. Zum Betrieb wird eine Lizenz benötigt. Sie können hier mit Ihrer E-Mail-Adresse eine Testlizenz herunterladen. Nach der Einreichung wird Ihnen die Lizenz per E-Mail zugestellt. Fügen Sie diese Lizenz am Anfang Ihres Codes ein, bevor Sie IronXL verwenden:

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")

Was haben wir über die Arbeit mit Excel-Dateien in C# gelernt?

IronXL ist eine leistungsstarke .NET Bibliothek zum Erstellen, Lesen und Bearbeiten von Excel-Dateien und bietet eine intuitive API, die die Arbeit mit Excel-Dokumenten vereinfacht. Es unterstützt mehrere Formate, darunter XLS, XLSX und CSV, wodurch es vielseitig für verschiedene Anwendungsfälle einsetzbar ist. IronXL ermöglicht eine einfache Manipulation von Zellwerten, Formeln und Formatierung und ist für die Leistung optimiert, was große Dateien und komplexe Operationen effizient verarbeitet. Durch sein Speichermanagement wird die Reaktionsfähigkeit von Anwendungen sichergestellt, und seine plattformübergreifende Kompatibilität macht es für Entwickler auf verschiedenen Betriebssystemen wertvoll.

Egal ob Sie Webanwendungen , Desktop-Software oder Cloud-Dienste entwickeln, IronXL bietet Ihnen die Werkzeuge, die Sie für die effektive Arbeit mit Excel-Dateien in C# benötigen. Weitere Funktionen finden Sie in der vollständigen Dokumentation und in den zahlreichen Codebeispielen .

Wichtige Punkte:

• Keine Installation von Microsoft Office erforderlich
• Plattformübergreifende Unterstützung für Windows, Linux und macOS
• Umfassende Styling- und Formatierungsoptionen
• Unterstützung für Formeln und Berechnungen
• Sicherheitsfunktionen einschließlich Passwortschutz
• Einfacher Datenexport und -import
• Hervorragende Leistungsoptimierungen

Bleiben Sie über die neuesten Funktionen und Verbesserungen auf dem Laufenden, indem Sie das Änderungsprotokoll und die Meilensteine ​​für die kontinuierlichen Weiterentwicklungen von IronXL überprüfen.