Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exporter vers Excel à partir de Gridview
UTILISATION D'IRONXL

Comment exporter des données d'un GridView vers Excel en C# avec IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

L'exportation des données GridView vers un fichier Excel authentique est l'une des exigences les plus courantes des applications web ASP.NET . Les approches traditionnelles utilisant HtmlTextWriter et StringWriter créent de faux fichiers Excel qui déclenchent des avertissements du navigateur et des erreurs de formatage lorsque les utilisateurs tentent de les ouvrir. Ce guide vous montre comment exporter les données GridView vers des fichiers correctement formatés .xlsx à l'aide IronXL , éliminant ainsi les maux de tête auxquels les développeurs sont confrontés avec les méthodes héritées.

Pourquoi l'approche traditionnelle d'exportation GridView pose-t-elle problème ?

La méthode classique d'exportation vers Excel à partir de GridView dans ASP.NET C# implique le rendu HTML et la définition des en-têtes Response avec les valeurs de nom de fichier de pièce jointe Content-Disposition. Cette approche nécessite de remplacer public override void VerifyRenderingInServerForm pour éviter les erreurs d'exécution. Le fichier résultant n'est pas un véritable fichier Excel -- il s'agit d'un fichier HTML déguisé avec une extension .xls, ce qui provoque l'affichage de messages d'avertissement dans Excel lorsque les utilisateurs l'ouvrent.

Plus précisément, la technique traditionnelle présente les inconvénients suivants :

Excel affiche un avertissement " Le format et l'extension du fichier ne correspondent pas " à chaque ouverture.

  • La mise en forme et les types de données sont perdus car les données sont stockées sous forme de HTML brut.
  • Vous devez implémenter VerifyRenderingInServerForm comme solution de contournement, ce qui augmente la dette technique de votre projet. Le fichier résultant ne contient pas les métadonnées de cellule appropriées, ce qui le rend inutilisable pour l'automatisation ou les outils de reporting en aval.

IronXL résout ces problèmes en créant de véritables fichiers Excel .xlsx sans nécessiter l'installation de Microsoft Office sur le serveur. Vous obtenez un fichier que n'importe quelle application tableur peut ouvrir sans problème, avec des types de données, un style et une structure OOXML corrects et préservés.

Comment installer IronXL dans votre projet ASP.NET ?

Avant d'écrire toute logique d'exportation, ajoutez IronXL à votre projet à l'aide du gestionnaire de packages NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package IronXl.Excel
Install-Package IronXl.Excel
SHELL

Vous pouvez également rechercher IronXl.Excel dans l'interface utilisateur du gestionnaire de packages NuGet et l'installer à partir de là. Une fois installé, vous pouvez faire référence à l'espace de noms IronXL dans n'importe quel fichier code-behind.

IronXL cible .NET Standard 2.0 et versions ultérieures, il fonctionne donc aussi bien avec les projets ASP.NET Core modernes qu'avec les applications ASP.NET Framework classiques. Aucune interopérabilité COM, aucune installation d'Office et aucune dépendance native supplémentaire ne sont requises sur votre serveur web.

Pour plus de détails, consultez le guide d'installation IronXL et la page du package NuGet IronXL .

Comment configurer le contrôle GridView ASP.NET pour l'exportation ?

Créez votre page Default.aspx avec un contrôle GridView et un bouton d'exportation. Le balisage est standard pour les formulaires Web :

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
$vbLabelText   $csharpLabel

Ce balisage crée une page simple avec un GridView lié et un bouton qui déclenche l'exportation. L'attribut AutoGenerateColumns="true" signifie que la grille lit les noms de colonnes directement à partir de la limite DataTable.

Liaison des exemples de données à la grille

Dans votre code-behind, liez un DataTable à la grille et stockez-le dans Session pour une utilisation ultérieure lors du postback d'exportation :

using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
$vbLabelText   $csharpLabel

Stocker le DataTable dans Session évite de réinterroger la base de données ou de reconstruire les données lors du postback déclenché par le bouton d'exportation. Pour les applications réelles, remplacez les lignes codées en dur par une requête de base de données utilisant Entity Framework ou .NET .

Exporter vers Excel depuis un GridView en .NET C# : Une solution C# propre : Image 1 - Interface utilisateur montrant les données d'exemple du GridView

Comment exporter des données GridView vers Excel à l'aide IronXL?

L'approche propre de l'exportation GridView convertit votre DataTable en un IronXL WorkBook et diffuse le résultat directement dans le navigateur. Voici la méthode d'exportation complète :

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
$vbLabelText   $csharpLabel

Comment fonctionne l'exportation étape par étape

Le processus se décompose en trois étapes logiques :

  1. Récupérer la DataTable -- Session["GridData"] renvoie la même DataTable qui était liée à la grille. Cela évite les appels de base de données en double.
  2. Créez le classeur -- WorkBook.LoadWorkSheetsFromDataSet crée automatiquement une feuille de calcul par DataTable dans le DataSet, en copiant les en-têtes de colonnes et les valeurs de lignes dans les cellules appropriées.
  3. Diffusion vers le navigateur -- Définir Content-Type sur le type MIME OOXML et écrire dans Response.OutputStream déclenche un téléchargement du navigateur avec l'extension correcte .xlsx. Aucun fichier temporaire n'est écrit sur le disque.

Ceci est fondamentalement différent de l'approche traditionnelle HtmlTextWriter. Le fichier exporté utilise le format Open XML — le même format que celui utilisé nativement par Microsoft Excel — il s'ouvre donc sans avertissement.

Pour plus d'informations sur le chargement de données par programmation, consultez la documentation IronXL WorkBook et la procédure d'exportation de DataTable vers Excel en C# .

Exporter vers Excel depuis GridView en .NET C# : Une solution C# propre : Image 2 - Fichier Excel exporté

Comment enregistrer le fichier Excel sur disque au lieu de le diffuser en continu ?

Si votre application doit archiver les exportations sur le serveur avant de fournir un lien de téléchargement à l'utilisateur, enregistrez le classeur dans un chemin de fichier plutôt que de le diffuser en continu vers Response.OutputStream :

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
$vbLabelText   $csharpLabel

Choisir entre le streaming et l'enregistrement sur disque

Comparaison des stratégies d'exportation en continu et sur disque
Stratégie Avantages Cons Idéal pour
Diffuser vers le navigateur Aucune utilisation de disque, livraison immédiate Impossible d'archiver ou de renvoyer Exportations utilisateur à la demande
Enregistrer sur le disque Le fichier est conservé pour vérification, téléchargement ultérieur ou envoi par courriel. Nécessite une tâche de nettoyage et la gestion de l'espace disque. Rapports programmés, pistes d'audit

Pour la plupart des applications web interactives, la diffusion directe vers le navigateur est la solution idéale. Enregistrez le fichier sur le disque dur uniquement si vous devez l'envoyer par courriel, le conserver à des fins de conformité ou autoriser les téléchargements ultérieurs depuis une page de gestion de fichiers.

Comment appliquer une mise en forme avancée à la feuille Excel exportée ?

IronXL vous offre un contrôle précis sur les styles de cellules, la largeur des colonnes, les formats de nombres, et bien plus encore. L'exemple suivant montre comment créer une exportation de style professionnel :

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
$vbLabelText   $csharpLabel

Options de mise en forme disponibles dans IronXL

IronXL expose un ensemble riche de propriétés de formatage via l'espace de noms IronXl.Styles :

  • Style de police : gras, italique, souligné, famille de polices et taille
  • Couleurs d'arrière-plan des cellules : les chaînes de couleurs hexadécimales sont acceptées directement.
  • Formats de nombres et de dates : toute chaîne de format Excel, y compris les modèles de devises, de pourcentages et de dates
  • Largeur de colonne : largeur manuelle en pixels ou AutoSizeColumn pour un ajustement automatique
  • Figer les volets : verrouiller les lignes ou colonnes d'en-tête pendant le défilement
  • Bordures des cellules : les quatre bordures sont personnalisables en termes de style et de couleur.
  • Fusionner les cellules -- combiner les cellules de plusieurs lignes ou colonnes pour les en-têtes de rapport

Pour obtenir la référence complète de l'API, consultez la documentation sur le style des cellules IronXL et la mise en forme des nombres IronXL .

Exporter vers Excel depuis GridView en .NET C# : Une solution C# propre : Image 3 - Document Excel formaté exporté

Comment gérer les grands ensembles de données lors des exportations GridView ?

Lorsque le GridView est lié à des milliers de lignes, quelques techniques permettent de garantir une exportation rapide et économe en mémoire :

Pagination et tableau de données côté serveur

N'exportez pas uniquement la page visible du GridView. Récupérez l'ensemble complet des données de votre source de données dans un DataTable avant d'appeler WorkBook.LoadWorkSheetsFromDataSet. IronXL écrit les lignes en une seule passe sans charger plusieurs fois l'intégralité du classeur en mémoire, ce qui le rend adapté aux dizaines de milliers de lignes.

Ajout de plusieurs feuilles de calcul

Vous pouvez inclure plusieurs objets DataTable dans le DataSet pour produire un classeur avec des onglets séparés :

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
$vbLabelText   $csharpLabel

Chaque DataTable.TableName devient le nom de l'onglet de la feuille de calcul dans Excel. Ce modèle convient parfaitement aux rapports de gestion qui combinent des données connexes issues de plusieurs vues.

Guides associés :

Quels sont les principaux avantages de l'utilisation IronXL pour l'exportation GridView ?

L'utilisation IronXL pour exporter les données de GridView offre des avantages indéniables par rapport à l'approche traditionnelle d'encapsulation HTML :

  • Fichiers Excel authentiques -- crée un format valide .xlsx qui s'ouvre sans avertissements ni messages d'erreur du navigateur
  • Aucune installation d'Office requise -- fonctionne sur n'importe quel serveur web sans interopérabilité avec Microsoft Excel ou Office
  • No VerifyRenderingInServerForm override -- élimine la solution de contournement répétitive qui encombre le code traditionnel
  • Contrôle total de la mise en forme : stylisez les cellules, appliquez des formats numériques, figez les volets et créez des feuilles de calcul Professional par programmation.
  • Prise en charge de plusieurs feuilles : exportez les ensembles de données associés sous forme d'onglets distincts dans un seul classeur.
  • Compatibilité multiplateforme : fonctionne correctement sur les serveurs Windows et Linux, y compris les conteneurs Docker et Azure App Service

La bibliothèque est disponible sur NuGet et prend en charge toutes les cibles .NET modernes, y compris .NET 10. Elle prend également en charge la lecture et l'écriture d'autres formats tels que CSV et ODS, ce qui en fait une dépendance unique pour tous les besoins de tableur de votre application.

Pour une comparaison côte à côte avec d'autres bibliothèques Excel, voir IronXL vs ClosedXML et la présentation des fonctionnalités IronXL .

Quelles sont vos prochaines étapes ?

Vous disposez désormais de tout ce dont vous avez besoin pour remplacer l'export GridView hérité HtmlTextWriter par une implémentation IronXL propre et sans avertissement. Voici comment procéder :

Questions Fréquemment Posées

Pourquoi utiliser IronXL pour exporter les données de GridView vers Excel ?

IronXL vous permet de créer de véritables fichiers XLSX à partir de GridView dans ASP.NET C# sans les problèmes courants associés à HtmlTextWriter et StringWriter, tels que les avertissements du navigateur et les erreurs de formatage.

Quelles sont les limitations de l'utilisation de HtmlTextWriter pour l'exportation vers Excel ?

HtmlTextWriter crée souvent de faux fichiers Excel, ce qui peut provoquer des avertissements du navigateur et des problèmes de mise en forme. IronXL résout ces problèmes en générant de véritables fichiers Excel.

Comment IronXL améliore-t-il le processus d'exportation de données depuis GridView ?

IronXL simplifie l'exportation de données depuis GridView en permettant aux développeurs de générer des fichiers Excel correctement formatés directement depuis leurs applications ASP.NET , évitant ainsi le recours à des solutions de contournement basées sur HTML.

Quel format de fichier IronXL utilise-t-il pour les fichiers Excel exportés ?

IronXL exporte les données vers de véritables fichiers XLSX, garantissant ainsi la compatibilité et un formatage correct lors de leur ouverture dans Excel.

IronXL peut-il résoudre les problèmes de formatage lors de l'exportation vers Excel ?

Oui, IronXL élimine les problèmes de formatage en créant de véritables fichiers Excel, ce qui garantit que les données s'affichent correctement sans déclencher d'avertissements du navigateur.

Existe-t-il un exemple de code pour exporter des données GridView avec IronXL?

Oui, le tutoriel inclut des exemples de code montrant comment utiliser IronXL pour exporter efficacement les données de GridView vers Excel.

IronXL prend-il en charge l'exportation de grands ensembles de données depuis GridView ?

IronXL est conçu pour gérer efficacement de grands ensembles de données, ce qui le rend adapté à l'exportation de données volumineuses de GridView vers Excel.

Quels sont les avantages de l'utilisation IronXL par rapport aux méthodes traditionnelles d'exportation Excel ?

IronXL offre une solution plus fiable et efficace, éliminant les avertissements du navigateur, garantissant un formatage correct des fichiers et fournissant une implémentation de code simple pour l'exportation des données GridView.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi