IronXL ist eine leistungsstarke C#-Bibliothek, die es Entwicklern ermöglicht, Excel-Dateien zu lesen, zu schreiben und zu bearbeiten, ohne dass eine Installation von Microsoft Excel erforderlich ist. Sie bietet plattformübergreifende Kompatibilität und unterstützt Formate wie XLS, XLSX und CSV mit einer intuitiven API.

Wie arbeite ich mit einem Excel-Arbeitsbuch in C#?

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 für .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 Sie 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 Bereicheinstellung mit WorkSheet["A1:B10"] Syntax.

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:

Welche Voraussetzungen müssen für die Nutzung von IronXL erfüllt sein?

1. .NET Framework: IronXL unterstützt .NET Framework 4.5 und höher .
2. .NET Core und .NET Standard: Kompatibel mit .NET Core 2, 3, 5, 6, 7, 8 und 9 .
3. Betriebssysteme: Funktioniert unter Windows, macOS und Linux . Kompatibel mit Docker , Azure und AWS .
4. Microsoft Office wird nicht benötigt: IronXL benötigt weder Office noch Excel Interop .
5. Code-Editor: Ein beliebiger C#-Code-Editor wie Visual Studio.

Wie installiere ich IronXL in meinem Projekt?

Sie können IronXL über den NuGet-Paketmanager in Visual Studio oder mithilfe der Paket-Manager-Konsole mit dem folgenden Befehl installieren:

dotnet add package IronXL.Excel --version 2024.8.5

Detailliertere Installationsanweisungen, einschließlich der Einrichtung für Blazor , .NET MAUI oder VB .NET -Projekte, finden Sie in der offiziellen Dokumentation .

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 WorkingWith IronXL
{
    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 WorkingWith IronXL
{
    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");
        }
    }
}

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 CreateWorkSheet Methode auf, um ein Arbeitsblatt im Arbeitsbuch zu erstellen.
4. Fügen Sie Werte zu Zellen hinzu mit workSheet["A1"].Value.
5. Speichern Sie die Excel-Datei mit workBook.SaveAs, indem Sie einen Dateinamen angeben.

Ausgabedatei Excel

Warum benötigt IronXL keine Interoperabilität?

Im Gegensatz zu herkömmlichen Ansätzen, die auf Microsoft Excel Interop angewiesen sind, ist IronXL eine eigenständige .NET Bibliothek, die Excel-Dateien direkt liest und schreibt. Das bedeutet:

• Keine Installation von Microsoft Office erforderlich
• Bessere Leistung und Speichernutzung
• Plattformübergreifende Kompatibilität ( Linux , macOS , Docker )
• Keine Probleme bei der Bereinigung von COM-Objekten
• Thread-sichere Operationen

In welchen Dateiformaten kann ich speichern?

IronXL unterstützt das Speichern in mehreren Formaten :

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

' 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

Wie gehe ich mit Fehlern während der Dateierstellung um?

IronXL bietet eine umfassende Fehlerbehandlung. Hier ein Beispiel für eine bewährte Vorgehensweise:

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

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

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 WorkingWith IronXL
{
    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 WorkingWith IronXL
{
    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");
        }
    }
}

Code-Erklärung

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

Ausgabedatei Excel

Welche Styling-Optionen stehen zur Verfügung?

IronXL bietet umfangreiche Styling-Optionen, darunter:

• Schrifteigenschaften : Schriftart, Größe, Farbe , fett, kursiv, unterstrichen, durchgestrichen
• Zellenränder : Randstile und -farben für alle vier Seiten
• Hintergrund : Hintergrundfarben und -muster
• Ausrichtung : Optionen für horizontale und vertikale Ausrichtung
• Zahlenformate : Benutzerdefinierte Formate für Datumsangaben, Währungen und Prozentsätze

Wie wende ich Formatvorlagen auf mehrere Zellen an?

Sie können Formatvorlagen effizient auf Zellbereiche anwenden:

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

' 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

Kann ich bedingte Formatierung verwenden?

Ja, IronXL unterstützt bedingte Formatierung :

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

' 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 WorkingWith IronXL
{
    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 WorkingWith IronXL
{
    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}");
        }
    }
}

Code-Erklärung

1. Load an Excel file using WorkBook.Load.
2. Greifen Sie auf das erste Arbeitsblatt in der Arbeitsmappe zu.
3. Lesen Sie den Wert einer bestimmten Zelle und zeigen Sie ihn an mit Console.WriteLine.
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.

Eingabedatei Excel

Ausgabe

Welche Datentypen kann ich aus Zellen lesen?

IronXL unterstützt das Lesen verschiedener Datentypen aus Zellen:

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

' 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

Wie gehe ich mit leeren oder Null-Zellen um?

IronXL bietet sichere Möglichkeiten zum Umgang mit leeren Zellen:

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

' 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

Welche Aggregatfunktionen stehen zur Verfügung?

IronXL unterstützt verschiedene Aggregatfunktionen :

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

' 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 WorkingWith IronXL
{
    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 WorkingWith IronXL
{
    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);
        }
    }
}

Code-Erklärung

1. Laden Sie die Excel-Datei mit der Load Methode.
2. Legen Sie Optionen für die HTML-Konvertierung fest mit HtmlExportOptions.
3. Verwenden Sie die ExportToHtml Methode zum Konvertieren und Speichern als HTML.

Eingabe

Ausgabe

Welche HTML-Exportoptionen stehen zur Verfügung?

IronXL bietet verschiedene HTML-Exportoptionen :

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 = New HtmlExportOptions() With {
    .OutputRowNumbers = True,
    .OutputColumnHeaders = True,
    .OutputHiddenRows = False,
    .OutputHiddenColumns = False,
    .OutputLeadingSpacesAsNonBreaking = True,
    .TableCssClass = "excel-table"
}

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

Wie kann ich die Formatierung in HTML beibehalten?

IronXL behält beim Export nach HTML automatisch die grundlegende Formatierung bei. Für die erweiterte Formatierungserhaltung:

// 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 with inline CSS styles
workBook.ExportToHtml("styled.html", New HtmlExportOptions With {
    .OutputRowNumbers = False,
    .OutputColumnHeaders = True,
    ' Preserves cell styles as inline CSS
    .PreserveStyles = True
})

Kann ich nur bestimmte Arbeitsblätter exportieren?

Ja, Sie können einzelne Arbeitsblätter exportieren:

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

' 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.

Welche Branchen profitieren am meisten von IronXL?

Branchen, die mit großen Mengen strukturierter Daten arbeiten, profitieren am meisten:

• Finanzen und Bankwesen (Berichte und Analysen)
• Gesundheitswesen ( sichere Datenverwaltung )
• Bildung (Notenverwaltung und Berichterstattung)
• E-Commerce ( Datenexport und -import )
• Fertigung (Bestands- und Produktionsverfolgung)

Wie bewältigt IronXL die Verarbeitung großer Datenmengen?

IronXL ist für optimale Leistung ausgelegt mit:

• Effiziente Speicherverwaltung für große Dateien
• Streaming-Funktionen für riesige Datensätze
• Unterstützung für Hintergrundverarbeitung
• Sicherer Betrieb mit mehreren Threads

Was sind gängige Integrationsszenarien?

Zu den üblichen Integrationsszenarien gehören:

• ASP.NET Webanwendungen für Datei-Uploads/Downloads
• Azure Functions für die cloudbasierte Verarbeitung
• SQL-Datenbankintegration zur Datensynchronisierung
• Blazor Anwendungen für interaktive Web-UIs
• Docker-Container für Microservices

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"

License.LicenseKey = "your Key Here"

Welche Lizenzarten sind verfügbar?

IronXL bietet verschiedene Lizenztypen an:

• Lite -Lizenz : Für einzelne Entwickler
• Professional License: For small teams
• Enterprise : Für große Organisationen
• SaaS-Lizenz : Für cloudbasierte Anwendungen
• OEM-Lizenz : Zur Weiterverbreitung

Wie wende ich den Lizenzschlüssel an?

Sie können den Lizenzschlüssel auf verschiedene Arten anwenden :

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

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

Bei Webanwendungen können Sie die Lizenz auch in der Web.config-Datei festlegen .

Was geschieht nach Ablauf der Probezeit?

Wenn die Testphase abläuft: Auf den generierten Dateien erscheint ein Wasserzeichen.

• Einige Funktionen sind möglicherweise eingeschränkt
• Produktionsbereitstellung nicht zulässig

Um IronXL weiterhin nutzen zu können, erwerben Sie eine kommerzielle Lizenz . Das Team bietet Lizenzverlängerungen und Upgrades für Bestandskunden an.

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.