Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exporter DataGridView vers Excel VB .NET
UTILISATION D'IRONXL

Comment exporter un DataGridView vers un fichier Excel en VB.NET : un exemple pratique utilisant IronXL

Jordi Bardia
Jordi Bardia
Publié:

Exportez les données DataGridView vers Excel en VB.NET à l'aide de la bibliothèque IronXL, qui élimine les dépendances à Microsoft Office et permet un déploiement compatible avec les conteneurs. Il suffit de créer un WorkBook , de parcourir les cellules DataGridView et d'enregistrer au format XLSX.

L'exportation de données d'un DataGridView Windows Forms vers Excel est une exigence courante dans les applications d'entreprise. Qu'il s'agisse de générer des rapports, de créer des sauvegardes de données ou de partager des informations avec les parties prenantes, les développeurs ont besoin d'un moyen fiable d'exporter les données GridView au format Excel. Bien que les approches traditionnelles utilisant Microsoft Office Interop aient rempli cet objectif, elles présentent des complexités de déploiement et des exigences de dépendance qui peuvent compliquer la distribution des applications.

Ce tutoriel présente un exemple pratique en VB.NET d'exportation des données DataGridView vers Excel à l'aide d'IronXL , une puissante bibliothèque .NET qui élimine le besoin d'installer Microsoft Office. Nous allons explorer comment mettre en œuvre une solution d'exportation propre et efficace qui fonctionne dans différents environnements, y compris les plateformes cloud et les conteneurs, ce qui la rend idéale pour les scénarios modernes de manipulation .NET Excel. Que vous déployiez sur Azure ou exécutiez des applications dans des conteneurs Docker , IronXL offre la flexibilité de déploiement dont les équipes DevOps ont besoin.

! La page d'accueil d'IronXL présente un exemple de code C# permettant de lire des fichiers Excel sans Microsoft Office ni Excel Interop, avec coloration syntaxique et statistiques de téléchargement NuGet.

Pourquoi l'exportation de DataGridView vers Excel est-elle essentielle ?

Les contrôles DataGridView sont fondamentaux pour les applications Windows Forms, car ils permettent d'afficher des données tabulaires avec lesquelles les utilisateurs interagissent quotidiennement. Exporter ces données vers Excel permet aux utilisateurs de tirer parti des puissants outils d'analyse d'Excel, de créer des présentations et de partager des données avec des collègues qui n'ont peut-être pas accès à l'application. Cette fonctionnalité d'exportation Excel de VB.NET est essentielle pour les flux de travail de reporting et d'analyse de données en entreprise.

Les méthodes d'exportation traditionnelles utilisant Microsoft.Office.Interop.Excel nécessitent qu'Excel soit installé sur chaque machine exécutant l'application. Cela crée des défis de déploiement, en particulier dans les environnements serveurs ou lors de la distribution d'applications à des utilisateurs sans licences Office. De plus, les approches Interop peuvent souffrir de fuites de mémoire et de problèmes de nettoyage des objets COM si elles ne sont pas manipulées avec soin. Ces difficultés deviennent particulièrement aiguës lors du déploiement sur AWS Lambda ou d'autres plateformes sans serveur où l'installation d'Office n'est pas possible.

Les applications modernes .NET exigent des solutions plus flexibles. IronXL relève ces défis en fournissant une bibliothèque autonome qui génère des fichiers Excel sans aucune dépendance à Microsoft Office. Cette approche garantit une fonctionnalité cohérente dans les environnements de développement, de test et de production, tout en prenant en charge le déploiement sur des conteneurs et des plateformes cloud. La prise en charge native de Linux et la compatibilité macOS de la bibliothèque la rendent idéale pour les déploiements multiplateformes. Une clé de licence valide est requise pour une utilisation en production afin de débloquer toutes les fonctionnalités.

! Diagramme de prise en charge multiplateforme montrant la compatibilité .NET sur plusieurs versions (9, 8, 7, 6, Core, Standard, Framework) avec des icônes pour diverses plateformes, notamment Windows, Linux, Mac, Docker, Azure et AWS.

Comment exporter GridView vers Excel (exemple VB .NET) en utilisant IronXL ?

Commençons par configurer IronXL dans votre projet VB.NET. Ouvrez la Console du Gestionnaire de Packages dans Visual Studio et installez IronXL avec cette commande :

Install-Package IronXL.Excel

! Sortie du terminal indiquant l'installation réussie du package NuGet IronXL.Excel et de ses dépendances dans un projet VB.NET

Pour des options d'installation détaillées, consultez le guide d'installation d'IronXL. Une fois installé, ajoutez Imports IronXL à vos fichiers de projet VB.NET pour accéder aux fonctionnalités d'exportation Excel de la bibliothèque. Lors du déploiement en environnement de production, vous devrez appliquer votre clé de licence pour activer toutes les fonctionnalités sans filigrane.

Nous allons tout d'abord créer une application Windows Forms d'exemple avec un DataGridView rempli de données. Voici le code complet pour configurer le formulaire et implémenter la fonctionnalité d'exportation, conçu dans un souci de simplicité de déploiement :

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
VB .NET

Ce code illustre les fonctionnalités d'exportation de base optimisées pour les scénarios de déploiement. La méthode SetupControls crée le DataGridView et le bouton d'exportation, et les positionne sur le formulaire. La méthode LoadSampleData remplit la grille avec des exemples de données de produits à l'aide d'un DataTable , qui sert de source de données commune pour les contrôles DataGridView dans les applications VB.NET. Lorsque vous travaillez avec des ensembles de données plus volumineux, vous pouvez tirer parti des fonctionnalités d'importation et d'exportation de jeux de données d'IronXL pour améliorer les performances.

La méthode ExportToExcel gère le processus d'exportation proprement dit. Il crée un nouveau WorkBook IronXL au format XLSX, puis parcourt le DataGridView pour exporter les en-têtes et les données dans la feuille Excel. La méthode SetCellValue permet d'insérer efficacement des valeurs dans les cellules Excel en utilisant les indices de ligne et de colonne. Pour des scénarios plus complexes, vous pouvez utiliser les opérations de sélection de plage pour manipuler plusieurs cellules simultanément. Le code utilise la propriété IsNewRow pour ignorer la ligne vide qui apparaît en bas des DataGridViews modifiables. Cette approche garantit une sortie Excel propre sans lignes blanches inattendues.

Si vous implémentez cette fonctionnalité dans une application ASP.NET MVC basée sur le Web, vous l'étendrez davantage en renvoyant le fichier sous forme de réponse téléchargeable. Dans ce cas, vous utiliseriez l'en-tête HTTP Content-Disposition pour spécifier si le fichier Excel doit être affiché en ligne dans le navigateur ou forcé en tant que pièce jointe à télécharger. Après la fin du cycle de vie de la page rendue, le fichier est envoyé au client. De même, les développeurs ASP.NET WebForms peuvent avoir besoin de redéfinir la méthode publique override void VerifyRenderingInServerForm lors de l'exportation des contrôles afin de garantir un rendu correct. Pour les déploiements conteneurisés, les dépendances minimales d'IronXL en font un excellent choix pour les architectures de microservices.

À quoi ressemble le résultat de l'exportation ?

Application Windows Forms affichant un DataGridView rempli de données produit, notamment les colonnes ID produit, Nom, Catégorie, Prix et Stock, avec un bouton " Exporter vers Excel " en dessous.

! Feuille de calcul Microsoft Excel présentant les données produits exportées, avec des colonnes pour l'identifiant du produit, le nom du produit, la catégorie, le prix et les niveaux de stock pour les accessoires électroniques et informatiques.

Pour les applications ASP.NET basées sur le Web, vous pouvez étendre cette fonctionnalité en renvoyant le fichier sous forme de réponse téléchargeable. Utilisez l'en-tête HTTP Content-Disposition pour spécifier si le fichier Excel doit s'afficher directement ou être téléchargé de force. Les développeurs ASP.NET WebForms peuvent avoir besoin de redéfinir la méthode publique override void VerifyRenderingInServerForm lors de l'exportation de contrôles tels que GridView vers Excel, afin de garantir un rendu correct en dehors du cycle de vie normal de la page. Pour les applications Blazor , IronXL assure une intégration transparente avec le rendu côté serveur.

Comment améliorer votre exportation Excel avec le formatage ?

Les exportations Excel professionnelles nécessitent souvent un formatage pour améliorer la lisibilité. IronXL offre de nombreuses possibilités de personnalisation du style qui peuvent être appliquées lors du processus d'exportation, notamment la personnalisation de la police et de la taille des cellules , ainsi que les options de bordure et d'alignement . Voici une version améliorée qui inclut le formatage :

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

Cette version améliorée applique un formatage professionnel au fichier Excel exporté. Les en-têtes reçoivent du texte en gras avec un fond bleu et une couleur de police blanche, créant une distinction visuelle claire. Le code implémente des couleurs de ligne alternées en utilisant une opération modulo simple, améliorant la lisibilité des grands ensembles de données. Vous pouvez personnaliser davantage l'apparence avec des motifs et des couleurs d'arrière-plan ou appliquer une mise en forme conditionnelle en fonction des valeurs des cellules.

La méthode AutoSizeColumn ajuste automatiquement la largeur des colonnes au contenu, éliminant ainsi les réglages manuels après l'exportation. Ces options de formatage transforment une exportation de données basique en un document prêt à être présenté que les utilisateurs peuvent partager immédiatement. Pour des mises en page plus complexes, envisagez d'utiliser la fonction de fusion de cellules pour créer des en-têtes s'étendant sur plusieurs colonnes.

Quelles sont les options d'exportation supplémentaires offertes par IronXL ?

IronXL va au-delà de l'exportation Excel de base, offrant des fonctionnalités qui améliorent la fonctionnalité et la flexibilité. Voici quelques fonctionnalités puissantes que vous pouvez intégrer, notamment des fonctions mathématiques et la prise en charge de plusieurs formats :

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

IronXL prend en charge les formules Excel , ce qui vous permet d'ajouter des calculs directement aux fichiers exportés. L'exemple montre l'ajout d'une formule SOMME pour calculer les totaux des colonnes. La création de plusieurs feuilles de calcul permet d'organiser les exportations complexes, par exemple en séparant les données détaillées des informations récapitulatives. Vous pouvez également implémenter des plages nommées et des tables nommées pour une meilleure organisation des données.

La flexibilité de format de la bibliothèque est particulièrement précieuse. Alors que le format XLSX est la norme pour les fichiers Excel, l'exportation CSV offre une compatibilité universelle avec les systèmes de bases de données et les applications plus anciennes. Les formats JSON et XML facilitent l'échange de données avec les services web et les API, rendant IronXL adapté à divers scénarios d'intégration. En savoir plus sur la conversion entre les formats dans la documentation. Pour les déploiements de conteneurs, cette flexibilité vous permet de prendre en charge plusieurs formats d'exportation sans dépendances supplémentaires.

Comment se comparent les différents formats d'exportation ?

! Feuille de calcul Excel affichant un inventaire de produits avec des colonnes pour l'ID du produit, le nom, la catégorie, le prix et le stock, avec un résultat de formule de somme de 1839,95 affiché dans la cellule D9.

! Feuille de calcul Excel montrant une feuille de calcul " Résumé " avec " Total des produits : 5 " dans les cellules A1 et B1, démontrant le résultat de l'exportation des données DataGridView vers Excel avec plusieurs feuilles de calcul.

! Feuille de calcul Excel affichant les données d'inventaire des produits avec des colonnes pour ProductID, Product Name, Category, Price et Stock Quantitys, avec une somme de 1839,95 affichée dans la cellule D9.

! Fichier JSON affichant les données produit avec les champs ID produit, Nom, Catégorie, Prix et Stock dans une interface d'éditeur de code.

! Fichier XML affichant les données DataGridView exportées avec les informations produit, notamment les identifiants, les noms, les catégories, les prix et les niveaux de stock, organisés en éléments de feuille.

Comment IronXL simplifie-t-il votre processus de développement ?

Le plus grand avantage d'IronXL est d'éliminer les dépendances à Microsoft Office. Votre application fonctionne de manière cohérente qu'elle soit déployée sur un poste de travail de développeur, une machine client ou un conteneur Docker. Cette indépendance simplifie le déploiement et réduit les problèmes de support liés aux versions et installations d'Office. Les fonctionnalités de sécurité de la bibliothèque garantissent la protection de vos applications contre les vulnérabilités.

Le design de l'API de la bibliothèque privilégie la simplicité. Contrairement à l'approche basée sur COM d'Interop nécessitant une élimination minutieuse des objets, IronXL utilise des modèles standards .NET qui paraissent naturels pour les développeurs VB.NET. Le support multiplateforme signifie que la fonctionnalité d'exportation de votre application Windows Forms peut être réutilisée dans des applications ASP.NET Core fonctionnant sur des serveurs Linux. Pour une documentation et des exemples complets, visitez la référence API d'IronXL. Lorsque vous travaillez avec des données sensibles, vous pouvez chiffrer les classeurs avec des mots de passe ou protéger les feuilles de calcul individuelles .

! Aperçu des fonctionnalités d'une bibliothèque Excel VB.NET présentant six catégories principales : Créer, Enregistrer et Exporter, Modifier les classeurs, Travailler avec les données, Sécuriser vos classeurs et Modifier les options de mise en page.

Pourquoi choisir IronXL pour vos exportations Excel ?

L'exportation des données DataGridView vers Excel devient simple avec IronXL. La bibliothèque élimine les complexités traditionnelles d'Interop tout en offrant des capacités de formatage professionnel et plusieurs formats d'exportation. Son architecture adaptée aux conteneurs, ses dépendances minimales et sa compatibilité multiplateforme en font la solution idéale pour les flux de travail DevOps modernes. Que vous développiez des microservices, déployiez sur des clusters Kubernetes ou exécutiez des fonctions sans serveur, IronXL s'intègre parfaitement à vos pipelines CI/CD.

Prêt à transformer vos capacités d'exportation Excel en VB.NET ? Commencez par un essai gratuit pour découvrir toutes les fonctionnalités. Les tutoriels complets et les exemples de code d'IronXL vous aident à mettre en œuvre rapidement des solutions prêtes pour la production. Choisissez parmi des options de licence flexibles adaptées à vos besoins de déploiement, allant des licences pour un seul développeur aux déploiements d'entreprise illimités.

Les options de licence IronXL se déclinent en quatre niveaux : Lite (749 $), Plus (999 $), Professionnel (1 999 $) et Illimité (3 999 $), avec des limites variables selon le développeur, la localisation et le projet.

Questions Fréquemment Posées

Quel est l'avantage d'utiliser IronXL pour exporter DataGridView vers Excel ?

IronXL simplifie le processus d'exportation du contenu de DataGridView vers Excel en éliminant le besoin d'Interop de Microsoft Office, réduisant les complexités de déploiement et supprimant les exigences de dépendance.

Comment IronXL améliore-t-il la distribution des applications ?

IronXL réduit les complexités de distribution des applications en ne nécessitant pas l'Interop de Microsoft Office, qui inclut souvent des dépendances supplémentaires pouvant compliquer le déploiement.

IronXL peut-il exporter des données DataGridView en VB.NET ?

Oui, IronXL fournit une solution pratique pour exporter les données DataGridView vers Excel en VB.NET, facilitant la gestion des données dans les applications d'affaires.

Quels sont les cas d'utilisation courants pour exporter DataGridView vers Excel ?

Les cas d'utilisation courants incluent la génération de rapports, la création de sauvegardes de données et le partage d'informations avec les parties prenantes dans un contexte d'affaires.

IronXL nécessite-t-il l'installation de Microsoft Excel sur le système ?

Non, IronXL ne nécessite pas l'installation de Microsoft Excel, car il fonctionne indépendamment d'Excel, simplifiant ainsi le processus de déploiement.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit