Wie man Excel-Dateien in C# mit IronXL öffnet

Warum IronXL gegenüber Microsoft.Office.Interop.Excel wählen?

Während Microsoft.Office.Interop.Excel der traditionelle Ansatz für die Excel-Automatisierung war, weist er erhebliche Einschränkungen auf, die IronXL zur besseren Wahl für moderne Anwendungen machen. Microsoft selbst rät von der Verwendung von Office Interop auf Servern ab und verweist auf Instabilität, Skalierbarkeitsprobleme und nicht unterstützte Bereitstellungsszenarien.

IronXL beseitigt die Abhängigkeit von Microsoft Excel und eignet sich daher ideal für Serverumgebungen, Docker-Container und Cloud-Plattformen wie Azure . Die Bibliothek bietet eine saubere, moderne API, die die Neintwendigkeit der Bearbeitung von COM-Objekten oder der manuellen Speicherverwaltung überflüssig macht. Neben dem Öffnen von Dateien übernimmt IronXL alles von der Formelauswertung über die Diagrammerstellung bis hin zur Zellformatierung .

Wie installiert man IronXL in einem .NET -Projekt?

Der Einstieg in IronXL ist unkompliziert – es kann innerhalb weniger Minuten über den NuGet Package Manager zu Ihrem Projekt hinzugefügt werden. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Beide Befehle installieren dasselbe Paket. Verwenden Sie die erste Methode in der Visual Studio Package Manager Console und die zweite mit der .NET CLI. Nach der Installation können Sie überprüfen, ob die Paketreferenz in Ihrer Projektdatei unter <PackageReference Include="IronXL.Excel" /> erscheint.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten

Wie öffnet und liest man eine bestehende Excel-Datei in C#?

Das Öffnen bestehender Excel-Dateien mit IronXL erfordert nur wenige Zeilen Code. Die Bibliothek unterstützt das Lesen von XLS- und XLSX-Dateien sowie von CSV- und TSV-Dateien über eine einheitliche API. Das folgende Beispiel veranschaulicht den wesentlichen Arbeitsablauf:

// Load an existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");

// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];

// Or access a worksheet by name
WorkSheet namedSheet = workbook.GetWorkSheet("January Sales");

// Read a specific cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Read a numeric value
decimal revenue = sheet["B2"].DecimalValue;
Console.WriteLine($"Revenue: {revenue:C}");

// Check cell data type before reading
var cell = sheet["C3"];
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}");

// Load an existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");

// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];

// Or access a worksheet by name
WorkSheet namedSheet = workbook.GetWorkSheet("January Sales");

// Read a specific cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Read a numeric value
decimal revenue = sheet["B2"].DecimalValue;
Console.WriteLine($"Revenue: {revenue:C}");

// Check cell data type before reading
var cell = sheet["C3"];
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}");

' Load an existing Excel file
Dim workbook As WorkBook = WorkBook.Load("sales-data.xlsx")

' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)

' Or access a worksheet by name
Dim namedSheet As WorkSheet = workbook.GetWorkSheet("January Sales")

' Read a specific cell value
Dim cellValue As String = sheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Read a numeric value
Dim revenue As Decimal = sheet("B2").DecimalValue
Console.WriteLine($"Revenue: {revenue:C}")

' Check cell data type before reading
Dim cell = sheet("C3")
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}")

Die Methode WorkBook.Load() erkennt automatisch das Dateiformat - XLS, XLSX, CSV oder TSV - und führt das Parsing ohne zusätzliche Konfiguration durch. Sie greifen auf die Arbeitsblätter entweder über den Index mit workbook.WorkSheets[0] oder über den Namen mit GetWorkSheet() zu. Einzelne Zellwerte sind durch die Klammerschreibweise (sheet["A1"]) lesbar, wodurch der Code prägnant und aussagekräftig wird. Eine vollständige Liste der unterstützten Dateitypen finden Sie in der Open XML SDK Dokumentation zu SpreadsheetML und auf der IronXL NuGet Paketseite.

Für den typisierten Zugriff stellt IronXL Eigenschaften wie .StringValue, .DecimalValue, .IntValue, .BoolValue und .DateTimeValue direkt auf Zellen zur Verfügung. Dadurch entfällt das bei generischen objektbasierten APIs übliche Rätselraten über den Datentyp. Für komplexere Szenarien konsultieren Sie bitte den Leitfaden zum Arbeiten mit Excel-Bereichen und die Dokumentation zu Zelldatenformaten .

// Load from a byte array (e.g., from a database or HTTP response)
byte[] fileBytes = File.ReadAllBytes("sales-data.xlsx");
WorkBook workbookFromBytes = WorkBook.Load(fileBytes);

// Load from a MemoryStream
using var memStream = new MemoryStream(fileBytes);
WorkBook workbookFromStream = WorkBook.Load(memStream);

// Access data the same way regardless of source
WorkSheet sheet = workbookFromStream.DefaultWorkSheet;
Console.WriteLine(sheet["A1"].StringValue);

// Load from a byte array (e.g., from a database or HTTP response)
byte[] fileBytes = File.ReadAllBytes("sales-data.xlsx");
WorkBook workbookFromBytes = WorkBook.Load(fileBytes);

// Load from a MemoryStream
using var memStream = new MemoryStream(fileBytes);
WorkBook workbookFromStream = WorkBook.Load(memStream);

// Access data the same way regardless of source
WorkSheet sheet = workbookFromStream.DefaultWorkSheet;
Console.WriteLine(sheet["A1"].StringValue);

Imports System
Imports System.IO

' Load from a byte array (e.g., from a database or HTTP response)
Dim fileBytes As Byte() = File.ReadAllBytes("sales-data.xlsx")
Dim workbookFromBytes As WorkBook = WorkBook.Load(fileBytes)

' Load from a MemoryStream
Using memStream As New MemoryStream(fileBytes)
    Dim workbookFromStream As WorkBook = WorkBook.Load(memStream)

    ' Access data the same way regardless of source
    Dim sheet As WorkSheet = workbookFromStream.DefaultWorkSheet
    Console.WriteLine(sheet("A1").StringValue)
End Using

Wie erstellt man neue Excel-Arbeitsmappen in C#?

Das Erstellen neuer Excel-Dateien ist mit den Tabellenkalkulationsfunktionen von IronXL genauso unkompliziert. Das folgende Beispiel erstellt einen formatierten Quartalsbericht:

// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Add metadata
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Title = "Q1 Revenue Report";

// Create a named worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Q1 Report");

// Add header row
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Add data rows
sheet["A2"].Value = "Software Licenses";
sheet["B2"].Value = 120;
sheet["C2"].Value = 45000;

sheet["A3"].Value = "Support Contracts";
sheet["B3"].Value = 55;
sheet["C3"].Value = 27500;

// Add a SUM formula
sheet["C4"].Formula = "=SUM(C2:C3)";

// Apply number formatting
sheet["C2:C4"].FormatString = "$#,##0.00";

// Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx");
Console.WriteLine("Workbook saved successfully.");

// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Add metadata
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Title = "Q1 Revenue Report";

// Create a named worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Q1 Report");

// Add header row
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Add data rows
sheet["A2"].Value = "Software Licenses";
sheet["B2"].Value = 120;
sheet["C2"].Value = 45000;

sheet["A3"].Value = "Support Contracts";
sheet["B3"].Value = 55;
sheet["C3"].Value = 27500;

// Add a SUM formula
sheet["C4"].Formula = "=SUM(C2:C3)";

// Apply number formatting
sheet["C2:C4"].FormatString = "$#,##0.00";

// Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx");
Console.WriteLine("Workbook saved successfully.");

' Create a new workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

' Add metadata
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Title = "Q1 Revenue Report"

' Create a named worksheet
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Q1 Report")

' Add header row
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"

' Add data rows
sheet("A2").Value = "Software Licenses"
sheet("B2").Value = 120
sheet("C2").Value = 45000

sheet("A3").Value = "Support Contracts"
sheet("B3").Value = 55
sheet("C3").Value = 27500

' Add a SUM formula
sheet("C4").Formula = "=SUM(C2:C3)"

' Apply number formatting
sheet("C2:C4").FormatString = "$#,##0.00"

' Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx")
Console.WriteLine("Workbook saved successfully.")

Die Methode WorkBook.Create() initialisiert eine neue Arbeitsmappe in dem angegebenen Format. Sie können mit CreateWorkSheet() mehrere Arbeitsblätter hinzufügen, Zellen mit verschiedenen Datentypen wie Zeichenketten, Zahlen, Booleschen Werten und Daten füllen und Excel-Formeln direkt über die Formula-Eigenschaft anwenden. Die Bibliothek übernimmt die Datentypkonvertierung und die Excel-spezifischen Formatierungsanforderungen automatisch.

Zum Gestalten von Überschriften und Hinzufügen von Rahmen verwenden Sie die Cell Styling API . Informationen zur Erstellung von Berichten mithilfe von Vorlagen finden Sie im Leitfaden zum Exportieren aus vorhandenen Excel-Vorlagen .

Wie liest und verarbeitet man Excel-Tabellendaten in großen Mengen?

IronXL handhabt Datenextraktion und Massenverarbeitung effizient durch bereichsbasierte Operationen und DataTable-Konvertierung:

// Load a workbook and select the default sheet
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a rectangular range of cells
var range = sheet["A1:D10"];
foreach (var cell in range)
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Convert the worksheet to a DataTable for database integration
System.Data.DataTable dataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders: true);
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}");

// Use aggregate functions directly on a range
decimal total = sheet["C2:C10"].Sum();
decimal average = sheet["C2:C10"].Avg();
decimal maxValue = sheet["C2:C10"].Max();

Console.WriteLine($"Total: {total:C}");
Console.WriteLine($"Average: {average:C}");
Console.WriteLine($"Max: {maxValue:C}");

// Filter and find rows using LINQ on the DataTable
var highValue = dataTable.AsEnumerable()
    .Where(row => row.Field<decimal>("Revenue") > 10000)
    .ToList();
Console.WriteLine($"High-value rows: {highValue.Count}");

// Load a workbook and select the default sheet
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a rectangular range of cells
var range = sheet["A1:D10"];
foreach (var cell in range)
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Convert the worksheet to a DataTable for database integration
System.Data.DataTable dataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders: true);
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}");

// Use aggregate functions directly on a range
decimal total = sheet["C2:C10"].Sum();
decimal average = sheet["C2:C10"].Avg();
decimal maxValue = sheet["C2:C10"].Max();

Console.WriteLine($"Total: {total:C}");
Console.WriteLine($"Average: {average:C}");
Console.WriteLine($"Max: {maxValue:C}");

// Filter and find rows using LINQ on the DataTable
var highValue = dataTable.AsEnumerable()
    .Where(row => row.Field<decimal>("Revenue") > 10000)
    .ToList();
Console.WriteLine($"High-value rows: {highValue.Count}");

Imports System
Imports System.Data
Imports System.Linq

' Load a workbook and select the default sheet
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a rectangular range of cells
Dim range = sheet("A1:D10")
For Each cell In range
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Convert the worksheet to a DataTable for database integration
Dim dataTable As DataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders:=True)
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}")

' Use aggregate functions directly on a range
Dim total As Decimal = sheet("C2:C10").Sum()
Dim average As Decimal = sheet("C2:C10").Avg()
Dim maxValue As Decimal = sheet("C2:C10").Max()

Console.WriteLine($"Total: {total:C}")
Console.WriteLine($"Average: {average:C}")
Console.WriteLine($"Max: {maxValue:C}")

' Filter and find rows using LINQ on the DataTable
Dim highValue = dataTable.AsEnumerable() _
    .Where(Function(row) row.Field(Of Decimal)("Revenue") > 10000) _
    .ToList()
Console.WriteLine($"High-value rows: {highValue.Count}")

Die Bereichsauswahlsyntax (sheet["A1:D10"]) bietet eine elegante Möglichkeit, mit mehreren Zellen gleichzeitig zu arbeiten. Die Methode ToDataTable() konvertiert Arbeitsblattdaten in ein System.Data.DataTable, das direkt mit Entity Framework, Datenbindungssteuerelementen und SQL-Bulk-Copy-Operationen integriert werden kann. IronXL unterstützt auch Aggregatfunktionen -- Sum(), Avg(), Max(), und Min() -- direkt auf Bereichen, wodurch die Neintwendigkeit entfällt, manuellen Iterationscode zu schreiben.

Für die effiziente Verarbeitung sehr großer Datensätze konsultieren Sie bitte die vollständige IronXL -API-Referenz für Streaming- und Chunked-Verarbeitungsmuster.

WorkBook workbook = WorkBook.Load("products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Get total row and column counts
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns");

// Iterate over all rows and columns
for (int row = 1; row <= rowCount; row++)
{
    for (int col = 1; col <= colCount; col++)
    {
        var cell = sheet.GetCellAt(row, col);
        if (cell != null && !string.IsNullOrEmpty(cell.Text))
        {
            Console.WriteLine($"[{row},{col}] = {cell.Text}");
        }
    }
}

// Find the first cell containing specific text
var searchResult = sheet["A1:Z100"]
    .FirstOrDefault(c => c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase));

if (searchResult != null)
{
    Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}");
}

WorkBook workbook = WorkBook.Load("products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Get total row and column counts
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns");

// Iterate over all rows and columns
for (int row = 1; row <= rowCount; row++)
{
    for (int col = 1; col <= colCount; col++)
    {
        var cell = sheet.GetCellAt(row, col);
        if (cell != null && !string.IsNullOrEmpty(cell.Text))
        {
            Console.WriteLine($"[{row},{col}] = {cell.Text}");
        }
    }
}

// Find the first cell containing specific text
var searchResult = sheet["A1:Z100"]
    .FirstOrDefault(c => c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase));

if (searchResult != null)
{
    Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}");
}

Imports System
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("products.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Get total row and column counts
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount

Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns")

' Iterate over all rows and columns
For row As Integer = 1 To rowCount
    For col As Integer = 1 To colCount
        Dim cell = sheet.GetCellAt(row, col)
        If cell IsNot Nothing AndAlso Not String.IsNullOrEmpty(cell.Text) Then
            Console.WriteLine($"[{row},{col}] = {cell.Text}")
        End If
    Next
Next

' Find the first cell containing specific text
Dim searchResult = sheet("A1:Z100") _
    .FirstOrDefault(Function(c) c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase))

If searchResult IsNot Nothing Then
    Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}")
End If

Welche Einsatzszenarien unterstützt dieser Ansatz?

Einer der größten praktischen Vorteile von IronXL ist seine Fähigkeit, ohne dass Microsoft Office irgendwo auf dem System installiert sein muss, zu funktionieren. Dies schafft eine Bereitstellungsflexibilität, die Interop-basierte Lösungen schlichtweg nicht erreichen können:

Wie geht man mit gängigen Excel-Operationen über das reine Lesen hinaus um?

Das Lesen und Schreiben von Zellen ist nur die Grundlage. Die Automatisierung von Excel-Anwendungen in der Praxis umfasst typischerweise Formatierung, Formeln, Tabellenblattverwaltung und Formatkonvertierung.

WorkBook workbook = WorkBook.Load("report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Apply bold, font size, and background color to header row
var headerRange = sheet["A1:F1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;

// Format a currency column
sheet["D2:D100"].FormatString = "$#,##0.00";

// Apply a date format
sheet["E2:E100"].FormatString = "yyyy-MM-dd";

// Add borders to a data range
var dataRange = sheet["A1:F20"];
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin;

workbook.SaveAs("formatted-report.xlsx");

WorkBook workbook = WorkBook.Load("report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Apply bold, font size, and background color to header row
var headerRange = sheet["A1:F1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;

// Format a currency column
sheet["D2:D100"].FormatString = "$#,##0.00";

// Apply a date format
sheet["E2:E100"].FormatString = "yyyy-MM-dd";

// Add borders to a data range
var dataRange = sheet["A1:F20"];
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin;

workbook.SaveAs("formatted-report.xlsx");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("report.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Apply bold, font size, and background color to header row
Dim headerRange = sheet("A1:F1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center

' Format a currency column
sheet("D2:D100").FormatString = "$#,##0.00"

' Apply a date format
sheet("E2:E100").FormatString = "yyyy-MM-dd"

' Add borders to a data range
Dim dataRange = sheet("A1:F20")
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin

workbook.SaveAs("formatted-report.xlsx")

// Load a CSV file and save as XLSX
WorkBook csvBook = WorkBook.Load("data-import.csv");
csvBook.SaveAs("data-import.xlsx");

// Load an XLSX file and export as CSV
WorkBook xlsxBook = WorkBook.Load("report.xlsx");
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv");

// Load a CSV file and save as XLSX
WorkBook csvBook = WorkBook.Load("data-import.csv");
csvBook.SaveAs("data-import.xlsx");

// Load an XLSX file and export as CSV
WorkBook xlsxBook = WorkBook.Load("report.xlsx");
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv");

' Load a CSV file and save as XLSX
Dim csvBook As WorkBook = WorkBook.Load("data-import.csv")
csvBook.SaveAs("data-import.xlsx")

' Load an XLSX file and export as CSV
Dim xlsxBook As WorkBook = WorkBook.Load("report.xlsx")
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv")

Wie starte ich eine kostenlose Testphase?

IronXL steht mit einer kostenlosen Entwicklerlizenz zum Download bereit, mit der Sie den vollen Funktionsumfang testen können, bevor Sie sich zum Kauf entscheiden. Während der Testphase gibt es keine Funktionsbeschränkungen – Sie evaluieren dieselbe Bibliothek, die auch in der Produktion zum Einsatz kommt.

Um loszulegen:

1. Installieren Sie das Paket über NuGet:

   dotnet add package IronXL

   dotnet add package IronXL

   SHELL
2. Besuchen Sie die IronXL -Lizenzseite , um einen kostenlosen Testschlüssel zu erhalten.
3. Wenden Sie den Schlüssel im Code an, bevor Sie IronXL aufrufen:

   IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

   IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

   Imports IronXL
   
   IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

   $vbLabelText   $csharpLabel

Lizenzen sind für einzelne Entwickler, Teams und Organisationen erhältlich. Auf der IronXL Produktseite finden Sie alle Preisdetails und Bereitstellungsoptionen, einschließlich lizenzgebührenfreier Vertriebsrechte. Einen umfassenderen Überblick über alle Iron Software Produkte und deren Integration finden Sie in der Iron Software Suite .