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 DataGridView-Steuerelement ist eine seiner meistgenutzten Komponenten: Es zeigt, bearbeitet und verwaltet tabellarische Daten aus jeder bindbaren Quelle wie einem DataTable, einem Datenbankabfrageergebnis oder einer im Speicher befindlichen Liste.

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

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Wie füllt man ein DataGridView mit Beispieldaten?

Für diesen Durchgang enthält das Formular ein DataGridView namens DataGridView1 und einen Button namens btnExport. Das Gitter wird im Load-Ereignis 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 DataSource-Eigenschaft bindet das DataTable direkt an das DataGridView, und das Gitter 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 Blatt zurück, ohne dass Sie eines explizit erstellen müssen. Die äußere Schleife schreibt Kopftexten aus 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. Die row + 1 Verschiebung verlagert Daten unter die Kopfzeile. SaveAs schreibt das fertige Arbeitsbuch als Open XML XLSX-Datei an den angegebenen Pfad.

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

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 GetRange-Methode akzeptiert Standard-Excel-Neintation (A1:D1), um einen zusammenhängenden Block von Zellen auszuwählen. Das Setzen von Style.Font.Bold, Style.SetBackgroundColor und Style.Font.SetColor wendet diese Formate auf jede Zelle im ausgewählten Bereich an. Für numerische Spalten bewahrt das Schreiben des Wertes als decimal statt als Zeichenfolge den Datentyp, was bedeutet, dass Excel die Zahlenformatierung wie $#,##0 korrekt anwenden kann. Als Zeichenketten gespeicherte Zellen reagieren nicht auf numerische Formatcodes.

Sie können dieses Muster erweitern, um abwechselnde Zeilenbeschattung, automatische Spaltenbreitenanpassung oder Freeze-Panes hinzuzufügen, indem Sie die IronXL-Styling-Dokumentation zu Rate ziehen.

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 das DataGridView an einen DataTable gebunden ist, können Sie die Tabelle direkt in IronXL laden, indem Sie die Methode WorkSheet.LoadDataTable verwenden, wodurch die Zelle-für-Zelle-Iteration vollständig umgangen wird. Dieser Ansatz ist schneller und erhält automatisch alle Spaltentypen.

Für Gitter, die nicht von einem DataTable unterstützt werden, bleibt das weiter oben gezeigte Zelle-für-Zelle-Muster der Standardansatz. Wenn Sie asynchron exportieren müssen, um die Benutzeroberfläche während großer Exporte reaktionsfähig zu halten, packen Sie die Exportlogik in einen Task.Run-Aufruf und await das Ergebnis in einem Hintergrund-Thread. 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 nutzten 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 voll verwaltet .NET, sodass die Müllsammlung den Speicher automatisch ohne Aufrufe von Marshal.ReleaseComObject verwaltet. 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 ein breiteres Funktionsspektrum einschließlich PDF-Konvertierung, Diagrammerzeugung und kommerziellen Support, was bei Beschaffungsentscheidungen in Unternehmen ausschlaggebend sein könnte. 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 haben nun einen funktionierenden C#-Code, um ein DataGridView mit IronXL in eine formatierte Excel-Datei zu exportieren. Beachten Sie ab hier die folgenden Anweisungen:

• Fehlerbehandlung hinzufügen: Umgeben Sie den Exportcode mit einem try/catch-Block und zeigen Sie eine benutzerfreundliche Nachricht an, falls die Datei gesperrt ist oder der Pfad ungültig ist
• Unterstützen Sie die Auswahl des Dateipfads: Verwenden Sie SaveFileDialog, um es Benutzern zu ermöglichen, den Ausgabepfad und den Dateinamen zur Laufzeit auszuwählen
• Echte Daten laden: Ersetzen Sie das Beispielfeld DataTable durch eine Datenbankabfrage mit ADO.NET oder Entity Framework
• Vorhandene Dateien lesen: Verwenden Sie WorkBook.Load, um eine bestehende Tabelle zu öffnen und zu aktualisieren, anstatt immer eine neue zu erstellen
• In mehrere Blätter exportieren: Erstellen Sie zusätzliche WorkSheet-Objekte in derselben WorkBook, um verwandte 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.