Wie man DataGridView in C# mit IronXL nach Excel exportiert

Wie richtet man ein Windows Forms-Projekt für den Excel-Export ein?

Windows Forms ist eine grundlegende GUI-Bibliothek im .NET Ökosystem und wird häufig zum Erstellen von Desktop-Anwendungen verwendet. Das Steuerelement DataGridView ist eine seiner am häufigsten verwendeten Komponenten: Es zeigt tabellarische Daten aus beliebigen bindbaren Quellen an, wie z. B. DataTable, einem Datenbankabfrageergebnis oder einer Liste im Arbeitsspeicher.

Der Export dieser Rasterdaten nach Excel erfüllt verschiedene alltägliche Bedürfnisse – das Versenden von Berichten an Stakeholder, das Archivieren von Momentaufnahmen für Prüfungszwecke oder das Einspeisen von Daten in nachgelagerte Analysetools. Die beiden traditionellen Ansätze sind Microsoft Office Interop und Drittanbieterbibliotheken. Interop erfordert die Installation einer Kopie von Excel auf jedem Rechner, auf dem die Anwendung ausgeführt wird, verursacht Probleme im Lebenszyklus von COM-Objekten und funktioniert schlecht bei Server- oder Cloud-Bereitstellungen. Bibliotheken wie IronXL , ClosedXML und Syncfusion umgehen diese Probleme, indem sie direkt in das Open XML-Dateiformat schreiben, ohne Abhängigkeiten von Office.

Dieser Leitfaden demonstriert den IronXL Ansatz in C# for .NET 10, obwohl IronXL .NET Framework 4.6.2 und alle modernen .NET Versionen unterstützt.

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Wie füllt man ein DataGridView mit Beispieldaten?

In diesem Beispiel enthält das Formular ein Element namens DataGridView und einen Button namens DataGridView1. Das Raster wird im Ereignis Load des Formulars mit Mitarbeiterdatensätzen gefüllt, die in einem DataTable gespeichert sind:

void Form1_Load(object sender, EventArgs e)
{
    var dt = new DataTable();

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

void Form1_Load(object sender, EventArgs e)
{
    var dt = new DataTable();

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

Option Strict On



Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim dt As New DataTable()

    ' Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", GetType(Integer))
    dt.Columns.Add("Name", GetType(String))
    dt.Columns.Add("Department", GetType(String))
    dt.Columns.Add("Salary", GetType(Decimal))

    ' Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000D)
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000D)
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000D)
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000D)

    DataGridView1.DataSource = dt
End Sub

Jede Spalte ist mit einem spezifischen .NET -Typ definiert, damit numerische Vergleiche und Formatierungen später korrekt funktionieren. Die Eigenschaft DataSource bindet DataTable direkt an DataGridView, und das Raster rendert automatisch alle Zeilen, wenn das Formular geöffnet wird. Im Produktionsbetrieb stammen diese Daten typischerweise aus einer Datenbankabfrage, einem ORM-Ergebnissatz oder einer REST-API-Antwort und nicht aus fest codierten Werten.

Wie exportiert man DataGridView-Daten mit Spaltenüberschriften in eine Excel-Datei?

Die Exportlogik befindet sich im Klick-Handler des Buttons. Der Code erstellt ein neues WorkBook, ruft das Standardarbeitsblatt ab, schreibt Spaltenüberschriften in die erste Zeile und schreibt dann jede Datenzeile darunter:

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers to row index 0
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers to row index 0
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

Private Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers to row index 0
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Write data rows starting at row index 1
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cellValue.ToString())
            End If
        Next
    Next

    Dim outputPath As String = "EmployeeData.xlsx"
    workbook.SaveAs(outputPath)
    MessageBox.Show("Export complete. File saved to: " & outputPath, "Success")
End Sub

Das WorkBook- Objekt repräsentiert die gesamte Excel-Datei im Speicher. DefaultWorkSheet gibt das erste Tabellenblatt zurück, ohne dass Sie explizit eines erstellen müssen. Die äußere Schleife schreibt den Header-Text von HeaderText in Zeile Null. Die verschachtelte Schleife durchläuft dann jede Datenzeile und prüft auf Nullwerte, bevor der Zellenwert in eine Zeichenkette umgewandelt wird. Der Offset row + 1 verschiebt die Daten unterhalb der Kopfzeile. SaveAs speichert die fertige Arbeitsmappe als Open XML XLSX-Datei im angegebenen Pfad.

Die resultierende Datei kann in Excel, Google Sheets oder jeder anderen Anwendung geöffnet werden, die das XLSX-Format lesen kann. Die Spaltenüberschriften erscheinen in der ersten Zeile, und alle Datenzeilen folgen in der gleichen Reihenfolge, in der sie in der DataGridView erschienen sind.

Wie wendet man die Zellenformatierung auf die exportierte Excel-Datei an?

Ein einfacher Datenexport ist zwar funktional, aber nicht präsentationsfertig. Mit der Styling-API von IronXL können Sie vor dem Speichern Fettdruck, Hintergrundfarben, Textfarben und Zahlenformate auf beliebige Zellbereiche anwenden:

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

Option Strict On



Sub ExportWithFormatting()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Style the header row: bold white text on blue background
    Dim headerRange = sheet.GetRange("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.SetBackgroundColor("#4472C4")
    headerRange.Style.Font.SetColor("#FFFFFF")

    ' Locate the Salary column index
    Dim salaryColIndex As Integer = -1
    For i As Integer = 0 To DataGridView1.Columns.Count - 1
        If String.Equals(DataGridView1.Columns(i).HeaderText, "Salary", StringComparison.OrdinalIgnoreCase) Then
            salaryColIndex = i
            Exit For
        End If
    Next

    ' Write data rows, preserving numeric types
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue Is Nothing Then Continue For

            Dim targetRow As Integer = row + 1

            If col = salaryColIndex Then
                ' Write salary as a true numeric decimal
                Dim decValue As Decimal
                If Decimal.TryParse(cellValue.ToString(), Globalization.NumberStyles.Number, Globalization.CultureInfo.InvariantCulture, decValue) Then
                    sheet.SetCellValue(targetRow, col, decValue)
                Else
                    sheet.SetCellValue(targetRow, col, cellValue.ToString())
                End If
            Else
                sheet.SetCellValue(targetRow, col, cellValue.ToString())
            End If
        Next
    Next

    ' Apply currency format to the salary column data range
    Dim salaryRange = sheet.GetRange("D2:D5")
    salaryRange.FormatString = "$#,##0"

    workbook.SaveAs("FormattedEmployeeData.xlsx")
End Sub

Die Methode GetRange akzeptiert die Standard-Excel-Notation (A1:D1), um einen zusammenhängenden Zellblock auszuwählen. Durch die Einstellung Style.Font.Bold, Style.SetBackgroundColor und Style.Font.SetColor werden diese Formate auf jede Zelle im ausgewählten Bereich angewendet. Bei numerischen Spalten bleibt der Datentyp erhalten, wenn der Wert als decimal anstatt als Zeichenkette geschrieben wird. Dies bedeutet, dass Excel Zahlenformatierungen wie $#,##0 korrekt anwenden kann. Als Zeichenketten gespeicherte Zellen reagieren nicht auf numerische Formatcodes.

Sie können dieses Muster erweitern, um abwechselnde Zeilenschattierungen, automatische Spaltenbreitenanpassung oder das Fixieren von Bereichen anzuwenden, indem Sie die IronXL -Styling-Dokumentation konsultieren.

Wie exportiert man DataGridView-Daten in das CSV-Format anstatt in das XLSX-Format?

Manche Arbeitsabläufe erfordern eine CSV-Ausgabe, um die Kompatibilität mit älteren Systemen oder schlanken Datenpipelines zu gewährleisten. IronXL ermöglicht den CSV-Export ohne zusätzliche Konfigurationsänderungen am Hauptcode:

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

Sub ExportToCsv()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cell As Object = DataGridView1.Rows(row).Cells(col).Value
            If cell IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cell.ToString())
            End If
        Next
    Next

    ' Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv")
End Sub

Die einzige Änderung gegenüber dem XLSX-Export ist die Dateierweiterung, die an SaveAs übergeben wird. IronXL erkennt die Dateiendung und serialisiert die Arbeitsmappe automatisch im richtigen Format. Diese Konsistenz bedeutet, dass Ihre Datenschreiblogik unabhängig vom Ausgabeformat identisch bleibt – ein erheblicher Vorteil gegenüber Bibliotheken, die für jedes Format separate Codepfade benötigen.

Der CSV-Export ist besonders nützlich, wenn der nachgelagerte Verbraucher ein Python-Pandas-Skript , ein Datenbank-Massenimport-Tool oder eine Analyseplattform ist, die keine binären XLSX-Dateien lesen kann.

Wie verarbeitet man große DataGridView-Datensätze effizient?

Bei Tabellen mit Zehntausenden von Zeilen spielt die Leistungsfähigkeit eine wichtige Rolle. Das folgende Muster reduziert den Speicherdruck, indem der gesamte Datensatz in einem einzigen Durchlauf erstellt wird:

Wenn die DataGridView an eine DataTable gebunden ist, können Sie die Tabelle direkt in IronXL laden, indem Sie die Methode WorkSheet.LoadDataTable verwenden und so die Iteration Zelle für Zelle vollständig umgehen. Dieser Ansatz ist schneller und erhält automatisch alle Spaltentypen.

Für Raster, die nicht durch ein DataTable unterstützt werden, bleibt das zuvor gezeigte zellenweise Vorgehen der Standardansatz. Wenn Sie asynchron exportieren müssen, um die UI während großer Exporte reaktionsfähig zu halten, kapseln Sie die Exportlogik in einen Task.Run-Aufruf und await das Ergebnis in einem Hintergrundthread. In der Dokumentation zu asynchronen Dateioperationen finden Sie Muster zum Zurücksenden von Ergebnissen an den UI-Thread.

Warum ist IronXL für den DataGridView-Export besser geeignet als Office Interop?

Traditionelle .NET Lösungen verwendeten Microsoft.Office.Interop.Excel, um einen laufenden Excel-Prozess zu steuern. Dieser Ansatz führt zu mehreren Problemen hinsichtlich Einsatz und Zuverlässigkeit:

• Auf jedem Rechner, auf dem die Anwendung ausgeführt wird, muss eine lizenzierte Kopie von Microsoft Excel installiert sein. Serverumgebungen und Cloud-Container können Office in der Regel nicht installieren.
• COM-Interop erfordert die explizite Freigabe jedes Objekts, um Speicherlecks und Zombie-Excel-Prozesse zu vermeiden. Die Fehlerbehandlung an der COM-Grenze ist ausführlich und fehleranfällig. Die Leistung verschlechtert sich schnell mit zunehmender Zeilenanzahl.

IronXL schreibt direkt in das OOXML-Dateiformat , ohne einen externen Prozess zu starten. Anwendungen werden als in sich abgeschlossene Einheiten bereitgestellt. Die API der Bibliothek ist vollständig verwaltetes .NET, sodass die Speicherbereinigung automatisch ohne Marshal.ReleaseComObject-Aufrufe erfolgt. Die Geschwindigkeit ist wesentlich höher, da keine Kommunikation zwischen den Prozessen stattfindet.

Für Teams, die Alternativen evaluieren, ist ClosedXML eine beliebte Open-Source-Option. IronXL bietet einen breiteren Funktionsumfang, einschließlich PDF-Konvertierung , Diagrammerstellung und kommerzieller Unterstützung, was bei Beschaffungsentscheidungen von Enterprise eine Rolle spielen kann. Prüfen Sie die IronXL -Lizenzoptionen , um die passende Stufe für Ihre Teamgröße und Ihr Einsatzszenario zu finden.

Der Tutorialbereich von IronXL behandelt das Lesen vorhandener Excel-Dateien, das Ändern von Vorlagen, das Generieren von Diagrammen und das Anwenden bedingter Formatierungen – alles Funktionen, die sich auf natürliche Weise aus dem hier gezeigten DataGridView-Exportmuster ergeben.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über funktionierenden C#-Code, um eine DataGridView-Datei mithilfe von IronXL in eine formatierte Excel-Datei zu exportieren. Beachten Sie ab hier die folgenden Anweisungen:

• Fehlerbehandlung hinzufügen : Den Exportcode in einen try/catch-Block einschließen und eine benutzerfreundliche Meldung anzeigen, falls die Datei gesperrt oder der Pfad ungültig ist.
• Unterstützung der Dateipfadauswahl : Verwenden Sie SaveFileDialog, um Benutzern die Auswahl des Ausgabespeicherorts und des Dateinamens zur Laufzeit zu ermöglichen.
• Laden Sie echte Daten : Ersetzen Sie das Beispiel DataTable durch eine Datenbankabfrage mit .NET oder Entity Framework.
• Vorhandene Dateien lesen : Verwenden Sie WorkBook.Load , um eine vorhandene Tabellenkalkulation zu öffnen und zu aktualisieren, anstatt immer eine neue zu erstellen.
• Export in mehrere Tabellenblätter : Erstellen Sie zusätzliche WorkSheet-Objekte im selben WorkBook-Tabellenblatt, um zusammengehörige Datensätze zu organisieren.
• Bedingte Formatierung anwenden : Zellen, die Schwellenwerte überschreiten, mithilfe der IronXL- API für bedingte Formatierung hervorheben.
• Überprüfen Sie die Lizenzoptionen : Eine kostenlose Testversion ist verfügbar; Die Lizenzstufen decken sowohl einzelne Entwickler als auch Enterprise ab.
• Durchsuchen Sie die vollständige API-Referenz : Die IronXL Objektreferenz dokumentiert jede verfügbare Klasse und Methode.