Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Importar vista de cuadrícula de Excel
USANDO IRONXL

Cómo importar Excel a GridView en ASP .NET C# con IronXL

Jordi Bardia
Jordi Bardia
Publicado:

Seamos honestos: intentar importar Excel a GridView en ASP .NET C# solía ser un dolor de cabeza. Entre luchar con las cadenas de conexión OLEDB y preocuparse si los controladores correctos están instalados en su servidor, una importación de datos "simple" puede convertirse rápidamente en una larga tarde de depuración.

No tiene por qué ser así. Con IronXL , puede omitir las configuraciones complejas y cerrar la brecha entre sus hojas de cálculo y su interfaz de usuario con solo unas pocas líneas de código. Esta guía le mostrará cómo extraer datos de Excel directamente en un DataTable y vincularlos a un GridView, lo que hará que el manejo de datos sea sencillo y, nos atrevemos a decir, agradable.

Pruébelo usted mismo: obtenga una prueba gratuita de IronXL para seguirlo con el código a continuación.

¿Cuál es la forma más rápida de cargar datos de Excel en un GridView?

El método más rápido para cargar datos desde archivos Excel en un GridView implica utilizar el método ToDataTable de IronXL. Este enfoque elimina las complejas cadenas de conexión y las dependencias de controladores que requieren los métodos tradicionales. Simplemente cargue el libro, seleccione la hoja de cálculo, conviértala a DataTable y asígnela como fuente de datos de GridView.

using IronXL;
using System.Data;
// Load the Excel file
WorkBook workBook = WorkBook.Load("data.xlsx");
// Access the first sheet
WorkSheet sheet = workBook.DefaultWorkSheet;
// Convert to DataTable for GridView binding
DataTable dataTable = sheet.ToDataTable(true);
using IronXL;
using System.Data;
// Load the Excel file
WorkBook workBook = WorkBook.Load("data.xlsx");
// Access the first sheet
WorkSheet sheet = workBook.DefaultWorkSheet;
// Convert to DataTable for GridView binding
DataTable dataTable = sheet.ToDataTable(true);
Imports IronXL
Imports System.Data

' Load the Excel file
Dim workBook As WorkBook = WorkBook.Load("data.xlsx")
' Access the first sheet
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Convert to DataTable for GridView binding
Dim dataTable As DataTable = sheet.ToDataTable(True)
$vbLabelText   $csharpLabel

> 💡 Consejo profesional: al usar sheet.ToDataTable(true), IronXL trata automáticamente la primera fila como encabezado. ¡Esto le ahorra el problema de nombrar manualmente las columnas en su código!

El método ToDataTable acepta un parámetro booleano que especifica si la primera fila contiene información de encabezado. Cuando se establece como verdadero, los nombres de columnas se asignan desde la primera fila de su hoja de cálculo de Excel. IronXL admite archivos XLS y XLSX sin problemas, manejando datos de celdas y formateándolos automáticamente.

¿Cómo se crea un proyecto ASP.NET para importar datos de Excel?

Para configurar su proyecto ASP.NET es necesario agregar IronXL a través del Administrador de paquetes NuGet. En Visual Studio, cree una nueva aplicación de formularios web ASP.NET y luego instale la biblioteca IronXL. El proceso de instalación agrega automáticamente todas las referencias necesarias a su proyecto.

Install-Package IronXL.Excel

Después de la instalación, agregue el espacio de nombres IronXL a su archivo de código subyacente junto con System.Data para obtener compatibilidad con DataTable. Su clave de licencia se puede aplicar al iniciar la aplicación o directamente en el evento de carga de la página.

¿Cómo se pueden importar archivos de Excel a GridView en ASP.NET C#?

El siguiente código demuestra una implementación completa para cargar un archivo Excel y mostrar su contenido en un control GridView. La página incluye un control FileUpload, un botón de carga y un GridView para mostrar los datos importados.

Marcado ASPX:

<asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="btnUpload" runat="server" Text="Upload" OnClick="btnUpload_Click" />
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true" />
<asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="btnUpload" runat="server" Text="Upload" OnClick="btnUpload_Click" />
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true" />
<asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="btnUpload" runat="server" Text="Upload" OnClick="btnUpload_Click" />
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true" />
$vbLabelText   $csharpLabel

Código subyacente (C#):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data;
using System.IO;
using IronXL;
namespace ExcelImportTest
{
    public partial class _Default : System.Web.UI.Page
    {
        // Add this property if it does not exist
        protected global::System.Web.UI.WebControls.GridView GridView1;
        protected global::System.Web.UI.WebControls.FileUpload FileUpload1;
        protected void Page_Load(object sender, EventArgs e)
        {
        }
        protected void btnUpload_Click(object sender, EventArgs e)
        {
            if (FileUpload1.HasFile)
            {
                try
                {
                    string path = Path.Combine(Server.MapPath("~/Uploads/"), FileUpload1.FileName);
                    FileUpload1.SaveAs(path);
                    WorkBook workBook = WorkBook.Load(path);
                    WorkSheet sheet = workBook.WorkSheets[0];
                    // 1. Manually create a DataTable
                    DataTable dt = new DataTable();
                    // 2. Create Columns based on the first row of Excel
                    var firstRow = sheet.Rows.First();
                    foreach (var cell in firstRow)
                    {
                        dt.Columns.Add(cell.Value.ToString());
                    }
                    // 3. Manually add the data rows (skipping the header row)
                    foreach (var row in sheet.Rows.Skip(1))
                    {
                        DataRow dr = dt.NewRow();
                        int colIndex = 0;
                        foreach (var cell in row)
                        {
                            dr[colIndex] = cell.Value?.ToString();
                            colIndex++;
                        }
                        dt.Rows.Add(dr);
                    }
                    // 4. Force the GridView to refresh
                    GridView1.DataSource = dt;
                    GridView1.DataBind();
                    Session["CurrentData"] = dt;
                }
                catch (Exception ex)
                {
                    Response.Write("Manual Load Error: " + ex.Message);
                }
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data;
using System.IO;
using IronXL;
namespace ExcelImportTest
{
    public partial class _Default : System.Web.UI.Page
    {
        // Add this property if it does not exist
        protected global::System.Web.UI.WebControls.GridView GridView1;
        protected global::System.Web.UI.WebControls.FileUpload FileUpload1;
        protected void Page_Load(object sender, EventArgs e)
        {
        }
        protected void btnUpload_Click(object sender, EventArgs e)
        {
            if (FileUpload1.HasFile)
            {
                try
                {
                    string path = Path.Combine(Server.MapPath("~/Uploads/"), FileUpload1.FileName);
                    FileUpload1.SaveAs(path);
                    WorkBook workBook = WorkBook.Load(path);
                    WorkSheet sheet = workBook.WorkSheets[0];
                    // 1. Manually create a DataTable
                    DataTable dt = new DataTable();
                    // 2. Create Columns based on the first row of Excel
                    var firstRow = sheet.Rows.First();
                    foreach (var cell in firstRow)
                    {
                        dt.Columns.Add(cell.Value.ToString());
                    }
                    // 3. Manually add the data rows (skipping the header row)
                    foreach (var row in sheet.Rows.Skip(1))
                    {
                        DataRow dr = dt.NewRow();
                        int colIndex = 0;
                        foreach (var cell in row)
                        {
                            dr[colIndex] = cell.Value?.ToString();
                            colIndex++;
                        }
                        dt.Rows.Add(dr);
                    }
                    // 4. Force the GridView to refresh
                    GridView1.DataSource = dt;
                    GridView1.DataBind();
                    Session["CurrentData"] = dt;
                }
                catch (Exception ex)
                {
                    Response.Write("Manual Load Error: " + ex.Message);
                }
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.Data
Imports System.IO
Imports IronXL

Namespace ExcelImportTest
    Partial Public Class _Default
        Inherits System.Web.UI.Page

        ' Add this property if it does not exist
        Protected GridView1 As Global.System.Web.UI.WebControls.GridView
        Protected FileUpload1 As Global.System.Web.UI.WebControls.FileUpload

        Protected Sub Page_Load(sender As Object, e As EventArgs)
        End Sub

        Protected Sub btnUpload_Click(sender As Object, e As EventArgs)
            If FileUpload1.HasFile Then
                Try
                    Dim path As String = Path.Combine(Server.MapPath("~/Uploads/"), FileUpload1.FileName)
                    FileUpload1.SaveAs(path)
                    Dim workBook As WorkBook = WorkBook.Load(path)
                    Dim sheet As WorkSheet = workBook.WorkSheets(0)

                    ' 1. Manually create a DataTable
                    Dim dt As New DataTable()

                    ' 2. Create Columns based on the first row of Excel
                    Dim firstRow = sheet.Rows.First()
                    For Each cell In firstRow
                        dt.Columns.Add(cell.Value.ToString())
                    Next

                    ' 3. Manually add the data rows (skipping the header row)
                    For Each row In sheet.Rows.Skip(1)
                        Dim dr As DataRow = dt.NewRow()
                        Dim colIndex As Integer = 0
                        For Each cell In row
                            dr(colIndex) = If(cell.Value?.ToString(), Nothing)
                            colIndex += 1
                        Next
                        dt.Rows.Add(dr)
                    Next

                    ' 4. Force the GridView to refresh
                    GridView1.DataSource = dt
                    GridView1.DataBind()
                    Session("CurrentData") = dt
                Catch ex As Exception
                    Response.Write("Manual Load Error: " & ex.Message)
                End Try
            End If
        End Sub
    End Class
End Namespace
$vbLabelText   $csharpLabel

Resultado

Cómo importar Excel a GridView en ASP .NET C# con IronXL: Imagen 1 - Importando nuestro archivo de Excel a GridView

Esta implementación maneja el proceso de importación completo. Cuando los usuarios hacen clic en el botón de carga, el archivo se guarda en una carpeta del servidor, IronXL carga el libro de trabajo y accede a la hoja de trabajo predeterminada; luego, DataTable completa la cuadrícula. La propiedad AutoGenerateColumns crea columnas automáticamente según la estructura de la hoja de Excel.

Para proyectos que requieren acceso a hojas específicas en lugar de la primera, utilice el método GetWorkSheet con el nombre de la hoja como parámetro de cadena.

¿Cómo acceder a hojas y columnas específicas de Excel?

IronXL ofrece métodos flexibles para acceder a hojas de cálculo y rangos de celdas específicos dentro de su archivo de Excel. Al trabajar con libros que contienen varias tablas en diferentes hojas, especifique exactamente qué datos importar.

// Access worksheet by name
WorkSheet sheet = workBook.GetWorkSheet("SalesData");
// Access specific cell range
var range = sheet["A1:D10"];
// Get dataset from entire workbook (all sheets)
DataSet dataSet = workBook.ToDataSet();
// Access worksheet by name
WorkSheet sheet = workBook.GetWorkSheet("SalesData");
// Access specific cell range
var range = sheet["A1:D10"];
// Get dataset from entire workbook (all sheets)
DataSet dataSet = workBook.ToDataSet();
' Access worksheet by name
Dim sheet As WorkSheet = workBook.GetWorkSheet("SalesData")
' Access specific cell range
Dim range = sheet("A1:D10")
' Get dataset from entire workbook (all sheets)
Dim dataSet As DataSet = workBook.ToDataSet()
$vbLabelText   $csharpLabel

Resultado

Cómo importar Excel a GridView en ASP .NET C# con IronXL: Imagen 2 - Salida para exportar una hoja de cálculo específica a GridView

El método ToDataSet convierte todas las hojas de trabajo en un DataSet que contiene múltiples objetos DataTable. Cada DataTable corresponde a una hoja de Excel, lo que facilita completar varias cuadrículas o procesar datos de varias hojas de forma independiente. Puede iterar a través de filas y columnas para acceder a valores de celdas individuales o aplicar formato según sea necesario.

¿Cómo puedo exportar datos de GridView a Excel?

Exportar datos desde GridView a un archivo Excel completa el flujo de trabajo de ida y vuelta. IronXL simplifica este proceso al aceptar la entrada de DataTable y crear archivos de hojas de cálculo con el formato adecuado.

protected void btnExport_Click(object sender, EventArgs e)
{
    // Create new workbook and worksheet
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("ExportedData");
    // Get DataTable from GridView
    DataTable dt = (DataTable)GridView1.DataSource;
    // Fill worksheet with header row
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    }
    // Fill data rows
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            workSheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
        }
    }
    // Save to server and provide download
    string exportPath = Server.MapPath("~/Exports/export.xlsx");
    workBook.SaveAs(exportPath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    // Create new workbook and worksheet
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("ExportedData");
    // Get DataTable from GridView
    DataTable dt = (DataTable)GridView1.DataSource;
    // Fill worksheet with header row
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    }
    // Fill data rows
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            workSheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
        }
    }
    // Save to server and provide download
    string exportPath = Server.MapPath("~/Exports/export.xlsx");
    workBook.SaveAs(exportPath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ' Create new workbook and worksheet
    Dim workBook As WorkBook = WorkBook.Create()
    Dim workSheet As WorkSheet = workBook.CreateWorkSheet("ExportedData")
    ' Get DataTable from GridView
    Dim dt As DataTable = DirectCast(GridView1.DataSource, DataTable)
    ' Fill worksheet with header row
    For col As Integer = 0 To dt.Columns.Count - 1
        workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Next
    ' Fill data rows
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            workSheet.SetCellValue(row + 1, col, dt.Rows(row)(col).ToString())
        Next
    Next
    ' Save to server and provide download
    Dim exportPath As String = Server.MapPath("~/Exports/export.xlsx")
    workBook.SaveAs(exportPath)
End Sub
$vbLabelText   $csharpLabel

Resultado

Cómo importar Excel a GridView en ASP .NET C# con IronXL: Imagen 3: Datos de DataTable exportados a Excel

Este método de exportación crea un nuevo libro de trabajo, transfiere el contenido de DataTable, incluidos los encabezados de columna, y guarda el resultado. El proceso preserva la estructura de datos mientras genera archivos XLSX válidos que se abren correctamente en Microsoft Excel y otras aplicaciones de hojas de cálculo.

Conclusión

IronXL agiliza el proceso de trabajo con archivos Excel en aplicaciones ASP.NET. La API intuitiva de la biblioteca maneja formatos de archivos XLS y XLSX, importa datos de Excel a objetos de tabla de datos para una fácil vinculación de GridView y admite la exportación de datos nuevamente al formato de hoja de cálculo. Para obtener aclaraciones sobre funciones avanzadas como formato de celdas, fórmulas o trabajo con grandes conjuntos de datos, explore la documentación de IronXL .

¿Está listo para implementar la integración de Excel-GridView en su aplicación web? Compre una licencia para desbloquear capacidades de producción completas o comuníquese con nuestro equipo para obtener ayuda con sus requisitos específicos.

Preguntas Frecuentes

¿Cuál es el beneficio de usar IronXL para importar Excel a GridView en ASP.NET C#?

El uso de IronXL simplifica la importación de datos de Excel a GridView en ASP.NET C#, eliminando la necesidad de complejas cadenas de conexión OLEDB e instalaciones de controladores. Permite a los desarrolladores cargar archivos XLS y XLSX, convertirlos en DataTables y mostrarlos en controles GridView con código sencillo.

¿Cómo maneja IronXL los diferentes formatos de archivos Excel?

IronXL admite varios formatos de archivo de Excel, como XLS y XLSX, lo que lo convierte en una herramienta versátil para importar datos a GridView. Garantiza compatibilidad y facilidad de uso en diferentes versiones de Excel.

¿Puede IronXL convertir archivos Excel a DataTables?

Sí, IronXL puede convertir archivos de Excel en tablas de datos, que luego se pueden visualizar fácilmente en controles GridView en ASP.NET C#. Esta función agiliza el proceso de manipulación y visualización de datos.

¿Es IronXL adecuado para archivos Excel grandes?

IronXL está diseñado para manejar archivos grandes de Excel de manera eficiente, lo que lo convierte en una opción confiable para proyectos que requieren importar cantidades sustanciales de datos a GridView en ASP.NET C#.

¿Cuáles son los problemas comunes que se evitan al utilizar IronXL?

Al utilizar IronXL, los desarrolladores pueden evitar problemas comunes como lidiar con cadenas de conexión OLEDB, compatibilidad de controladores de servidor y procesos complejos de importación de datos, reduciendo así el tiempo de depuración.

¿IronXL requiere alguna configuración de servidor especial?

No, IronXL no requiere configuraciones de servidor especiales ni controladores adicionales, lo que simplifica la implementación y reduce los gastos de mantenimiento.

¿Cómo mejora IronXL la productividad del desarrollo?

IronXL mejora la productividad del desarrollo al proporcionar una forma simple y eficiente de importar datos de Excel a GridView en ASP.NET C#, lo que permite a los desarrolladores concentrarse en otras tareas críticas sin empantanarse con las complejidades de la importación de datos.

¿Se puede integrar IronXL con aplicaciones ASP.NET C# existentes?

Sí, IronXL se puede integrar fácilmente en aplicaciones ASP.NET C# existentes, lo que permite una importación perfecta de datos de Excel a GridView sin cambios significativos en la arquitectura de la aplicación.

¿Qué lenguajes de programación son soportados por IronXL?

IronXL está diseñado principalmente para su uso en entornos C# y ASP.NET, proporcionando soporte sólido e integración para estos lenguajes de programación.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis