Wie man ein DataGridView in VB.NET in eine Excel-Datei exportiert: Ein praktisches Beispiel mit IronXL

Warum ist der DataGridView -zu-Excel-Export so wichtig?

DataGridView Steuerelemente sind grundlegend für Windows Forms-Anwendungen und dienen der Anzeige tabellarischer Daten, mit denen Benutzer täglich interagieren. Der Export dieser Daten nach Excel ermöglicht es den Benutzern, die leistungsstarken Analysetools von Excel zu nutzen, Präsentationen zu erstellen und Daten mit Kollegen zu teilen, die möglicherweise keinen Zugriff auf die Anwendung haben. Diese VB.NET Excel-Exportfunktion ist für Geschäftsberichte und Datenanalyse-Workflows von entscheidender Bedeutung.

Bei herkömmlichen Exportmethoden mit Microsoft.Office.Interop.Excel muss Excel auf jedem Rechner installiert sein, auf dem die Anwendung ausgeführt wird. Dies schafft Herausforderungen bei der Bereitstellung, insbesondere in Serverumgebungen oder bei der Verbreitung von Anwendungen an Benutzer ohne Office-Lizenzen. Darüber hinaus können Interop-Ansätze unter Speicherlecks und Problemen mit der Bereinigung von COM-Objekten leiden, wenn sie nicht sorgfältig behandelt werden. Diese Herausforderungen werden besonders akut bei der Bereitstellung auf AWS Lambda oder anderen serverlosen Plattformen, wo eine Office-Installation nicht möglich ist.

Moderne .NET-Anwendungen verlangen flexiblere Lösungen. IronXL adressiert diese Herausforderungen, indem es eine eigenständige Bibliothek bereitstellt, die Excel-Dateien ohne jegliche Microsoft Office-Abhängigkeiten generiert. Dieser Ansatz gewährleistet eine konsistente Funktionalität in Entwicklungs-, Test- und Produktionsumgebungen und unterstützt gleichzeitig die Bereitstellung auf Container- und Cloud-Plattformen. Die native Linux-Unterstützung und die macOS-Kompatibilität der Bibliothek machen sie ideal für plattformübergreifende Einsätze. Für den Produktiveinsatz ist ein gültiger Lizenzschlüssel erforderlich, um alle Funktionen freizuschalten.

! Diagramm zur plattformübergreifenden Unterstützung, das die .NET-Kompatibilität über mehrere Versionen (9, 8, 7, 6, Core, Standard, Framework) hinweg mit Symbolen für verschiedene Plattformen wie Windows, Linux, Mac, Docker, Azure und AWS zeigt.

Wie exportiert man GridView nach Excel? VB.NET-Beispiel mit IronXL?

Lassen Sie uns damit beginnen, IronXL in Ihrem VB.NET-Projekt einzurichten. Öffnen Sie die Paket-Manager-Konsole in Visual Studio und installieren Sie IronXL mit diesem Befehl:

Install-Package IronXL.Excel

Terminalausgabe, die die erfolgreiche Installation des IronXL.Excel NuGet-Pakets und seiner Abhängigkeiten in einem VB.NET-Projekt anzeigt.

Für detaillierte Installationsoptionen siehe den IronXL Installationsleitfaden. Nach der Installation fügen Sie Imports IronXL zu Ihren VB.NET-Projektdateien hinzu, um auf die Excel-Exportfunktionen der Bibliothek zugreifen zu können. Bei der Bereitstellung in Produktionsumgebungen müssen Sie Ihren Lizenzschlüssel anwenden, um alle Funktionen ohne Wasserzeichen zu aktivieren.

Zuerst erstellen wir eine Beispielanwendung für Windows Forms mit einem DataGridView , das mit Daten gefüllt ist. Hier ist der vollständige Code zum Einrichten des Formulars und zum Implementieren der Exportfunktionalität, der mit Blick auf eine einfache Bereitstellung entwickelt wurde:

Imports IronXL
Imports System.Windows.Forms
Imports System.Data
Public Class Form1
    ' Type GridView
    Private dataGridView1 As DataGridView
    Private btnExport As Button
    Public Sub New()
        InitializeComponent()
        SetupControls()
        LoadSampleData()
    End Sub
    Private Sub SetupControls()
        ' Initialize DataGridView
        dataGridView1 = New DataGridView()
        dataGridView1.Location = New Point(10, 10)
        dataGridView1.Size = New Size(450, 200)
        ' Initialize Export Button
        btnExport = New Button()
        btnExport.Text = "Export to Excel"
        btnExport.Location = New Point(10, 220)
        btnExport.Size = New Size(120, 30)
        AddHandler btnExport.Click, AddressOf ExportToExcel
        ' Add controls to form
        Me.Controls.Add(dataGridView1)
        Me.Controls.Add(btnExport)
        Me.Text = "DataGridView to Excel Export"
        Me.Size = New Size(500, 300)
    End Sub
    Private Sub LoadSampleData()
        ' Create sample DataTable
        Dim dt As New DataTable()
        dt.Columns.Add("Product ID", GetType(Integer))
        dt.Columns.Add("Product Name", GetType(String))
        dt.Columns.Add("Category", GetType(String))
        dt.Columns.Add("Price", GetType(Decimal))
        dt.Columns.Add("Stock", GetType(Integer))
        ' Add sample rows
        dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99, 15)
        dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99, 50)
        dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99, 100)
        dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99, 8)
        dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99, 25)
        ' Bind to DataGridView
        dataGridView1.DataSource = dt
    End Sub
    Private Sub ExportToExcel(ByVal sender As Object, ByVal e As EventArgs)
        Try
            ' Create new Excel workbook
            Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
            ' Export column headers
            For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                worksheet.SetCellValue(0, colIndex, dataGridView1.Columns(colIndex).HeaderText)
            Next
            ' Export data rows
            For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
                If Not dataGridView1.Rows(rowIndex).IsNewRow Then
                    For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                        Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
                        If TypeOf cellValue Is Decimal OrElse TypeOf cellValue Is Double OrElse TypeOf cellValue Is Integer Then
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue)
Else
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue.ToString())
End If
                    Next
                End If
            Next
            ' Save the Excel file
            Dim saveDialog As New SaveFileDialog()
            saveDialog.Filter = "Excel Files|*.xlsx"
            saveDialog.Title = "Save Excel File"
            saveDialog.FileName = "DataGridViewExport.xlsx"
            If saveDialog.ShowDialog() = DialogResult.OK Then
                workbook.SaveAs(saveDialog.FileName)
                MessageBox.Show("Export completed successfully!", "Success", 
                              MessageBoxButtons.OK, MessageBoxIcon.Information)
            End If
        Catch ex As Exception
            MessageBox.Show("Export failed: " & ex.Message, "Error", 
                          MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
End Class

Imports IronXL
Imports System.Windows.Forms
Imports System.Data
Public Class Form1
    ' Type GridView
    Private dataGridView1 As DataGridView
    Private btnExport As Button
    Public Sub New()
        InitializeComponent()
        SetupControls()
        LoadSampleData()
    End Sub
    Private Sub SetupControls()
        ' Initialize DataGridView
        dataGridView1 = New DataGridView()
        dataGridView1.Location = New Point(10, 10)
        dataGridView1.Size = New Size(450, 200)
        ' Initialize Export Button
        btnExport = New Button()
        btnExport.Text = "Export to Excel"
        btnExport.Location = New Point(10, 220)
        btnExport.Size = New Size(120, 30)
        AddHandler btnExport.Click, AddressOf ExportToExcel
        ' Add controls to form
        Me.Controls.Add(dataGridView1)
        Me.Controls.Add(btnExport)
        Me.Text = "DataGridView to Excel Export"
        Me.Size = New Size(500, 300)
    End Sub
    Private Sub LoadSampleData()
        ' Create sample DataTable
        Dim dt As New DataTable()
        dt.Columns.Add("Product ID", GetType(Integer))
        dt.Columns.Add("Product Name", GetType(String))
        dt.Columns.Add("Category", GetType(String))
        dt.Columns.Add("Price", GetType(Decimal))
        dt.Columns.Add("Stock", GetType(Integer))
        ' Add sample rows
        dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99, 15)
        dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99, 50)
        dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99, 100)
        dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99, 8)
        dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99, 25)
        ' Bind to DataGridView
        dataGridView1.DataSource = dt
    End Sub
    Private Sub ExportToExcel(ByVal sender As Object, ByVal e As EventArgs)
        Try
            ' Create new Excel workbook
            Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
            ' Export column headers
            For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                worksheet.SetCellValue(0, colIndex, dataGridView1.Columns(colIndex).HeaderText)
            Next
            ' Export data rows
            For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
                If Not dataGridView1.Rows(rowIndex).IsNewRow Then
                    For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                        Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
                        If TypeOf cellValue Is Decimal OrElse TypeOf cellValue Is Double OrElse TypeOf cellValue Is Integer Then
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue)
Else
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue.ToString())
End If
                    Next
                End If
            Next
            ' Save the Excel file
            Dim saveDialog As New SaveFileDialog()
            saveDialog.Filter = "Excel Files|*.xlsx"
            saveDialog.Title = "Save Excel File"
            saveDialog.FileName = "DataGridViewExport.xlsx"
            If saveDialog.ShowDialog() = DialogResult.OK Then
                workbook.SaveAs(saveDialog.FileName)
                MessageBox.Show("Export completed successfully!", "Success", 
                              MessageBoxButtons.OK, MessageBoxIcon.Information)
            End If
        Catch ex As Exception
            MessageBox.Show("Export failed: " & ex.Message, "Error", 
                          MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
End Class

Dieser Code demonstriert die Kernfunktionalität des Exports, optimiert für verschiedene Bereitstellungsszenarien. Die Methode SetupControls erstellt das DataGridView Steuerelement und die Export-Schaltfläche und positioniert diese auf dem Formular. Die LoadSampleData Methode füllt das Raster mit Beispielproduktdaten mithilfe einer DataTable , die als gemeinsame Datenquelle für DataGridView -Steuerelemente in VB.NET-Anwendungen dient. Bei der Arbeit mit größeren Datensätzen empfiehlt es sich, die DataSet-Import- und Exportfunktionen von IronXL zur Leistungssteigerung zu nutzen.

Die Methode ExportToExcel übernimmt den eigentlichen Exportvorgang. Es erstellt eine neue IronXL- WorkBook im XLSX-Format und durchläuft dann das DataGridView , um sowohl die Überschriften als auch die Daten in das Excel-Arbeitsblatt zu exportieren. Die SetCellValue Methode platziert Werte effizient in Excel-Zellen mithilfe von Zeilen- und Spaltenindizes. Für komplexere Szenarien können Sie mit Bereichsauswahloperationen mehrere Zellen gleichzeitig bearbeiten. Der Code verwendet die IsNewRow Eigenschaft, um die leere Zeile zu überspringen, die am unteren Rand von bearbeitbaren DataGridViews erscheint. Dieser Ansatz gewährleistet einen sauberen Excel-Ausgang ohne unerwartete leere Zeilen.

Wenn Sie diese Funktion in einer webbasierten ASP.NET MVC-Anwendung implementieren, können Sie sie noch erweitern, indem Sie die Datei als herunterladbare Antwort zurückgeben. In diesem Fall würden Sie den HTTP-Header Content-Disposition verwenden, um anzugeben, ob die Excel-Datei inline im Browser angezeigt oder als herunterladbarer Anhang erzwungen werden soll. Nach dem gerenderten Ende des Seitenlebenszyklus wird die Datei an den Client gesendet. In ähnlicher Weise müssen ASP.NET WebForms Entwickler möglicherweise die öffentliche Methode override voidVerifyRenderingInServerForm` überschreiben, wenn sie Steuerelemente exportieren, um eine korrekte Darstellung zu gewährleisten. Für containerisierte Bereitstellungen machen die minimalen Abhängigkeiten von IronXL es zu einer ausgezeichneten Wahl für Microservices-Architekturen.

Wie kann man den Excel-Export mit Formatierung verbessern?

Professionelle Excel-Exporte erfordern oft eine Formatierung, um die Lesbarkeit zu verbessern. IronXL bietet umfangreiche Gestaltungsmöglichkeiten, die während des Exportvorgangs angewendet werden können, darunter die Anpassung von Schriftart und -größe der Zellen sowie Optionen für Rahmen und Ausrichtung . Hier ist eine verbesserte Version, die Formatierungen beinhaltet:

' Object sender
Private Sub ExportToExcelWithFormatting(sender As Object, e As EventArgs)
    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Default Excel Worksheet
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
        ' Set column headers with formatting
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim headerCell = worksheet.GetCellAt(0, colIndex)
            headerCell.Value = dataGridView1.Columns(colIndex).HeaderText
            ' Apply header formatting
            headerCell.Style.Font.Bold = True
            headerCell.Style.BackgroundColor = "#4472C4"
            headerCell.Style.Font.Color = "#FFFFFF"
            headerCell.Style.HorizontalAlignment = HorizontalAlignment.Center
        Next
        ' Export data with alternating row colors
        For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
            If Not dataGridView1.Rows(rowIndex).IsNewRow Then
                For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                    Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
                    Dim excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex)
                    If cellValue IsNot Nothing Then
                        excelCell.Value = cellValue.ToString()
                    End If
                    ' Apply alternating row colors
                    If rowIndex Mod 2 = 0 Then
                        excelCell.Style.BackgroundColor = "#F2F2F2"
                    End If
                Next
            End If
        Next
        ' Auto-fit columns
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            worksheet.AutoSizeColumn(colIndex)
        Next
        ' Save formatted Excel file
        Dim saveDialog As New SaveFileDialog()
        saveDialog.Filter = "Excel Files|*.xlsx"
        If saveDialog.ShowDialog() = DialogResult.OK Then
            workbook.SaveAs(saveDialog.FileName)
            MessageBox.Show("Formatted export completed!", "Success")
        End If
    Catch ex As Exception
        MessageBox.Show("Export failed: " & ex.Message, "Error")
    End Try
End Sub

' Object sender
Private Sub ExportToExcelWithFormatting(sender As Object, e As EventArgs)
    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Default Excel Worksheet
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
        ' Set column headers with formatting
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim headerCell = worksheet.GetCellAt(0, colIndex)
            headerCell.Value = dataGridView1.Columns(colIndex).HeaderText
            ' Apply header formatting
            headerCell.Style.Font.Bold = True
            headerCell.Style.BackgroundColor = "#4472C4"
            headerCell.Style.Font.Color = "#FFFFFF"
            headerCell.Style.HorizontalAlignment = HorizontalAlignment.Center
        Next
        ' Export data with alternating row colors
        For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
            If Not dataGridView1.Rows(rowIndex).IsNewRow Then
                For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
                    Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
                    Dim excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex)
                    If cellValue IsNot Nothing Then
                        excelCell.Value = cellValue.ToString()
                    End If
                    ' Apply alternating row colors
                    If rowIndex Mod 2 = 0 Then
                        excelCell.Style.BackgroundColor = "#F2F2F2"
                    End If
                Next
            End If
        Next
        ' Auto-fit columns
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            worksheet.AutoSizeColumn(colIndex)
        Next
        ' Save formatted Excel file
        Dim saveDialog As New SaveFileDialog()
        saveDialog.Filter = "Excel Files|*.xlsx"
        If saveDialog.ShowDialog() = DialogResult.OK Then
            workbook.SaveAs(saveDialog.FileName)
            MessageBox.Show("Formatted export completed!", "Success")
        End If
    Catch ex As Exception
        MessageBox.Show("Export failed: " & ex.Message, "Error")
    End Try
End Sub

Diese verbesserte Version wendet professionelle Formatierungen auf die exportierte Excel-Datei an. Überschriften erhalten fett formatierten Text mit blauem Hintergrund und weißer Schriftfarbe, was eine klare visuelle Abgrenzung schafft. Der Code implementiert abwechselnde Zeilenfarben mit einer einfachen Modulo-Operation, was die Lesbarkeit für große Datensätze verbessert. Sie können das Erscheinungsbild zusätzlich mit Hintergrundmustern und -farben anpassen oder eine bedingte Formatierung basierend auf den Zellwerten anwenden.

Die Methode AutoSizeColumn passt die Spaltenbreiten automatisch an den Inhalt an, sodass keine manuelle Anpassung nach dem Export erforderlich ist. Diese Formatierungsoptionen verwandeln einen grundlegenden Datenexport in ein präsentationsfertiges Dokument, das die Benutzer sofort weitergeben können. Für komplexere Layouts empfiehlt sich die Verwendung der Funktion "Zellen verbinden" , um Überschriften zu erstellen, die sich über mehrere Spalten erstrecken.

Welche zusätzlichen Exportoptionen bietet IronXL an?

IronXL geht über den grundlegenden Excel-Export hinaus und bietet Funktionen, die die Funktionalität und Flexibilität erweitern. Hier sind einige leistungsstarke Funktionen, die Sie integrieren können, darunter mathematische Funktionen und Unterstützung für mehrere Formate:

' Add formulas to calculate totals
worksheet.SetCellValue(dataGridView1.Rows.Count + 2, 3, "=SUM(D2:D" & (dataGridView1.Rows.Count + 1) & ")")
' Create multiple worksheets for categorized data
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataGridView1.Rows.Count - 1)
' Export to different formats
workbook.SaveAsCsv("export.csv")     ' CSV format
workbook.SaveAsJson("export.json")   ' JSON format
workbook.SaveAsXml("export.xml")     ' XML format

' Add formulas to calculate totals
worksheet.SetCellValue(dataGridView1.Rows.Count + 2, 3, "=SUM(D2:D" & (dataGridView1.Rows.Count + 1) & ")")
' Create multiple worksheets for categorized data
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataGridView1.Rows.Count - 1)
' Export to different formats
workbook.SaveAsCsv("export.csv")     ' CSV format
workbook.SaveAsJson("export.json")   ' JSON format
workbook.SaveAsXml("export.xml")     ' XML format

IronXL unterstützt Excel-Formeln , sodass Sie Berechnungen direkt in exportierte Dateien einfügen können. Das Beispiel zeigt, wie man mit einer SUMME-Formel Spaltensummen berechnet. Die Erstellung mehrerer Arbeitsblätter erleichtert die Organisation komplexer Exporte, beispielsweise die Trennung detaillierter Daten von zusammenfassenden Informationen. Sie können auch benannte Bereiche und benannte Tabellen zur besseren Datenorganisation implementieren.

Die Flexibilität des Formats der Bibliothek ist besonders wertvoll. Während XLSX der Standard für Excel-Dateien ist, bietet der CSV-Export universelle Kompatibilität mit Datenbanksystemen und älteren Anwendungen. JSON- und XML-Formate erleichtern den Datenaustausch mit Webservices und APIs und machen IronXL für diverse Integrationsszenarien geeignet. Erfahren Sie mehr über das Konvertieren zwischen Formaten in der Dokumentation. Bei Container-Bereitstellungen ermöglicht diese Flexibilität die Unterstützung mehrerer Exportformate ohne zusätzliche Abhängigkeiten.

Wie vereinfacht IronXL Ihren Entwicklungsprozess?

Der größte Vorteil von IronXL ist die Beseitigung der Microsoft Office-Abhängigkeiten. Ihre Anwendung läuft konsistent, egal ob auf einem Entwicklerarbeitsplatz, einer Kundenmaschine oder einem Docker-Container bereitgestellt. Diese Unabhängigkeit vereinfacht die Bereitstellung und reduziert Supportprobleme, die mit Office-Versionen und -Installationen zusammenhängen. Die Sicherheitsfunktionen der Bibliothek gewährleisten, dass Ihre Anwendungen vor Sicherheitslücken geschützt bleiben.

Das API-Design der Bibliothek priorisiert Einfachheit. Anders als der Interop-Ansatz, der eine sorgfältige Objektfreigabe erfordert, verwendet IronXL Standard .NET-Muster, die sich für VB.NET-Entwickler natürlich anfühlen. Plattformübergreifende Unterstützung bedeutet, dass die Exportfunktion Ihrer Windows Forms-Anwendung in ASP.NET Core-Anwendungen wiederverwendet werden kann, die auf Linux-Servern laufen. Für umfassende Dokumentation und Beispiele besuchen Sie das IronXL API-Referenz. Beim Arbeiten mit sensiblen Daten können Sie Arbeitsmappen mit Passwörtern verschlüsseln oder einzelne Arbeitsblätter schützen .

Funktionsübersicht einer VB.NET Excel-Bibliothek mit sechs Hauptkategorien: Erstellen, Speichern und Exportieren, Bearbeiten von Arbeitsmappen, Arbeiten mit Daten, Sichern Ihrer Arbeitsmappen und Bearbeiten von Layoutoptionen.

Warum sollten Sie IronXL für Excel-Exporte wählen?

Mit IronXL wird der Export DataGridView Daten nach Excel zum Kinderspiel. Die Bibliothek beseitigt herkömmliche Interop-Komplexitäten und bietet professionelle Formatierungsfähigkeiten und mehrere Exportformate. Dank seiner containerfreundlichen Architektur, minimalen Abhängigkeiten und plattformübergreifenden Unterstützung ist es ideal für moderne DevOps Workflows. Egal ob Sie Microservices entwickeln, auf Kubernetes-Clustern bereitstellen oder serverlose Funktionen ausführen, IronXL integriert sich nahtlos in Ihre CI/CD-Pipelines.

Bereit, Ihre VB.NET-Excel-Exportfähigkeiten zu transformieren? Starten Sie mit einer kostenlosen Testversion , um alle Funktionen kennenzulernen. Die umfassenden Tutorials und Codebeispiele von IronXL helfen Ihnen, schnell produktionsreife Lösungen zu implementieren. Wählen Sie aus flexiblen Lizenzierungsoptionen , die Ihren Bereitstellungsanforderungen entsprechen – von Einzelentwicklerlizenzen bis hin zu unbegrenzten Unternehmensbereitstellungen.

IronXL bietet vier Lizenzstufen: Lite (749 $), Plus (999 $), Professional (1.999 $) und Unlimited (3.999 $) mit unterschiedlichen Entwickler-, Standort- und Projektlimits.