Importar datos de Excel a un GridView en ASP.NET C# es muy sencillo con IronXL. Cargas un libro de trabajo, conviertes una hoja de cálculo a un DataTable y lo vinculas a tu control GridView, todo sin controladores OLEDB o cadenas de conexión complejas.
> Pruébelo usted mismo: obtenga una versión de prueba gratuita de IronXL para seguir los ejemplos de código que se muestran a continuación.
Antes de escribir cualquier código, debe añadir IronXL a su proyecto ASP.NET. La forma más rápida es a través de NuGet, ya sea desde la consola del Administrador de paquetes de Visual Studio o desde la CLI de .NET.
Una vez instalado, NuGet añade todas las referencias necesarias a tu proyecto. No hay que instalar controladores externos, ni registrar proveedores OLEDB, ni existe dependencia de Microsoft Office en el servidor. La biblioteca se distribuye como un único ensamblado gestionado y funciona en Windows, Linux, macOS y entornos de alojamiento en la nube, incluido Azure App Service.
Tras la instalación, añada los siguientes espacios de nombres a cualquier archivo de código subyacente que lea o escriba datos de Excel:
using IronXL;
using System.Data;
using System.IO;Imports IronXL
Imports System.Data
Imports System.IOIronXL admite los formatos .xls (Excel 97-2003) y .xlsx (Excel 2007+), por lo que no necesitas manejos separados para cada tipo de archivo. La misma llamada WorkBook.Load maneja ambos formatos inspeccionando la firma del archivo automáticamente.
Las importaciones tradicionales de Excel basadas en OLEDB requieren el motor de base de datos de Microsoft Access (ACE o JET), que debe estar instalado en el servidor con la arquitectura de bits correcta (32 bits frente a 64 bits). La implementación en diferentes entornos de servidor suele fallar porque falta el controlador o este no es compatible, y Microsoft ya no incluye el controlador ACE de 64 bits con Windows de forma predeterminada.
IronXL elimina por completo esa dependencia. Lee el formato Open XML o BIFF sin procesar directamente en código gestionado. Se obtiene un comportamiento predecible en el desarrollo, el entorno de pruebas y la producción sin preocupaciones por la versión del controlador.
IronXL está destinado a .NET 10, .NET 8, .NET Standard 2.0 y .NET Framework 4.6.2+. Esta cobertura significa que puede utilizar la misma biblioteca tanto si su aplicación ASP.NET se ejecuta en Web Forms clásico, ASP.NET MVC o las modernas páginas Razor de .NET Core, sin necesidad de realizar cambios en el código de la capa de gestión de Excel. Puede encontrar el paquete IronXL en NuGet.org para consultar el historial de versiones y las notas de la versión antes de instalarlo.
El método más rápido combina WorkBook.Load, sheet.ToDataTable y GridView.DataBind en aproximadamente cuatro líneas de código efectivo. En los escenarios básicos no es necesario crear columnas manualmente ni iterar por las filas.
using IronXL;
using System.Data;
WorkBook workBook = WorkBook.Load("data.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// true = treat first row as column headers
DataTable dataTable = sheet.ToDataTable(true);
GridView1.DataSource = dataTable;
GridView1.DataBind();Imports IronXL
Imports System.Data
Dim workBook As WorkBook = WorkBook.Load("data.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' True = treat first row as column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)
GridView1.DataSource = dataTable
GridView1.DataBind()La llamada ToDataTable(true) indica a IronXL que promueva la primera fila de la hoja de cálculo a nombres de columna en el DataTable resultante. Cuando vinculas esa tabla a un GridView con AutoGenerateColumns="true", ASP.NET crea automáticamente una columna por cada encabezado de Excel.
Cada valor de celda en el DataTable se almacena como un string por defecto cuando llamas ToDataTable. Si tu aplicación necesita columnas tipadas, por ejemplo, decimal para datos de precios o DateTime para fechas, puedes leer los valores de celda individualmente a través del indexador WorkSheet y convertirlos al tipo .NET apropiado antes de llenar un DataTable fuertemente tipado.
Para una simple visualización en un GridView, las columnas de texto son suficientes porque la cuadrícula representa todos los valores como texto de todos modos.
Una página de importación mínima necesita tres controles: una entrada de carga de archivos, un botón de envío y el GridView. Agrega el siguiente marcado ASPX dentro de tu elemento <form runat="server">:
<asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="btnUpload" runat="server" Text="Upload Excel File"
OnClick="btnUpload_Click" />
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
CssClass="table table-bordered" /><asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="btnUpload" runat="server" Text="Upload Excel File" OnClick="btnUpload_Click" />
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true" CssClass="table table-bordered" />El atributo CssClass conecta la cuadrícula a tu hoja de estilos Bootstrap si estás usando una, proporcionando filas y bordes estilizados sin configuración adicional.
En el código subyacente, gestiona el evento de clic del botón. El siguiente patrón guarda el archivo cargado en una ruta de servidor temporal, lo carga con IronXL y vincula el DataTable resultante a la cuadrícula:
using IronXL;
using System.Data;
using System.IO;
void btnUpload_Click(object sender, EventArgs e)
{
if (!FileUpload1.HasFile) return;
string uploadDir = Server.MapPath("~/Uploads/");
Directory.CreateDirectory(uploadDir); // ensure directory exists
string filePath = Path.Combine(uploadDir, Path.GetFileName(FileUpload1.FileName));
FileUpload1.SaveAs(filePath);
WorkBook workBook = WorkBook.Load(filePath);
WorkSheet sheet = workBook.DefaultWorkSheet;
DataTable dt = sheet.ToDataTable(true);
GridView1.DataSource = dt;
GridView1.DataBind();
// Store for later export operations
Session["CurrentData"] = dt;
}Imports IronXL
Imports System.Data
Imports System.IO
Sub btnUpload_Click(sender As Object, e As EventArgs)
If Not FileUpload1.HasFile Then Return
Dim uploadDir As String = Server.MapPath("~/Uploads/")
Directory.CreateDirectory(uploadDir) ' ensure directory exists
Dim filePath As String = Path.Combine(uploadDir, Path.GetFileName(FileUpload1.FileName))
FileUpload1.SaveAs(filePath)
Dim workBook As WorkBook = WorkBook.Load(filePath)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
Dim dt As DataTable = sheet.ToDataTable(True)
GridView1.DataSource = dt
GridView1.DataBind()
' Store for later export operations
Session("CurrentData") = dt
End SubEsta implementación sigue el estilo de sentencias de nivel superior para la lógica dentro del controlador de eventos, al tiempo que conserva la firma de evento requerida de Web Forms. Observa que Directory.CreateDirectory se llama de manera defensiva: si la carpeta Uploads ya existe, la llamada no hace nada.
Después de que el usuario seleccione un archivo .xlsx y haga clic en el botón de carga, la cuadrícula se llena con el contenido de la hoja de cálculo. Los nombres de las columnas provienen de la primera fila del archivo de Excel, y todas las filas siguientes se convierten en filas de datos en la cuadrícula.
Para su uso en producción, debe comprobar la extensión del archivo y el tipo MIME antes de procesarlo. IronXL lanzará una excepción en formatos de archivo no compatibles, pero es mejor rechazar las subidas incorrectas a nivel del controlador antes de tocar el sistema de archivos:
string ext = Path.GetExtension(FileUpload1.FileName).ToBajoerInvariant();
string[] allowed = { ".xls", ".xlsx" };
if (!allowed.Contains(ext))
{
lblError.Text = "Only .xls and .xlsx files are accepted.";
return;
}Imports System.IO
Dim ext As String = Path.GetExtension(FileUpload1.FileName).ToLowerInvariant()
Dim allowed As String() = {".xls", ".xlsx"}
If Not allowed.Contains(ext) Then
lblError.Text = "Only .xls and .xlsx files are accepted."
Return
End IfTambién debes aplicar un tamaño máximo de archivo a través de los límites de solicitud de IIS o verificando FileUpload1.FileBytes.Length contra un umbral antes de llamar a SaveAs.
Cuando un libro de Excel contiene múltiples hojas, necesitas apuntar a una específica por nombre en lugar de depender de DefaultWorkSheet. IronXL proporciona un método GetWorkSheet que acepta el nombre de la pestaña de la hoja como una cadena.
using IronXL;
using System.Data;
WorkBook workBook = WorkBook.Load("sales-report.xlsx");
// Access a named sheet
WorkSheet salesSheet = workBook.GetWorkSheet("Q4 Sales");
// Read a specific cell range
var topTen = salesSheet["A1:E11"];
// Convert the entire workbook to a DataSet (one DataTable per sheet)
DataSet allSheets = workBook.ToDataSet();
// Bind the first sheet's DataTable to the grid
GridView1.DataSource = allSheets.Tables[0];
GridView1.DataBind();Imports IronXL
Imports System.Data
Dim workBook As WorkBook = WorkBook.Load("sales-report.xlsx")
' Access a named sheet
Dim salesSheet As WorkSheet = workBook.GetWorkSheet("Q4 Sales")
' Read a specific cell range
Dim topTen = salesSheet("A1:E11")
' Convert the entire workbook to a DataSet (one DataTable per sheet)
Dim allSheets As DataSet = workBook.ToDataSet()
' Bind the first sheet's DataTable to the grid
GridView1.DataSource = allSheets.Tables(0)
GridView1.DataBind()El método ToDataSet es útil cuando tu aplicación necesita mostrar datos de múltiples hojas o permitir al usuario elegir qué hoja ver. Cada DataTable en el DataSet devuelto corresponde a una hoja de cálculo de Excel, y el nombre de la tabla coincide con el nombre de la pestaña de la hoja.
Si solo deseas un subconjunto de las filas de Excel, por ejemplo, filas donde una columna 'Estado' es igual a 'Activo', lee el DataTable producido por ToDataTable, aplica un filtro DataView y vincula la vista filtrada a la cuadrícula:
DataTable dt = sheet.ToDataTable(true);
DataView dv = new DataView(dt)
{
RowFilter = "Status = 'Active'"
};
GridView1.DataSource = dv;
GridView1.DataBind();Dim dt As DataTable = sheet.ToDataTable(True)
Dim dv As New DataView(dt) With {
.RowFilter = "Status = 'Active'"
}
GridView1.DataSource = dv
GridView1.DataBind()DataView.RowFilter acepta la sintaxis estándar de la cláusula SQL WHERE, el mismo lenguaje de expresión documentado en la propiedad DataColumn.Expression en Microsoft Learn, dándote clasificación y filtrado sin cargar una base de datos.
Los diferentes enfoques para el enlace de Excel a GridView presentan distintas ventajas e inconvenientes. La tabla siguiente resume los métodos más comunes para que puedas elegir el más adecuado para tu caso.
| Método | Se requiere controlador | Compatibilidad con XLS | Compatibilidad con XLSX | Dependencia del servidor | Complejidad del código |
|---|---|---|---|---|---|
| IronXL (ToDataTable) | None | Sí | Sí | None | Bajo |
| OLEDB / JET | Motor ACE/JET | Sí | Parcial | Controlador de 32/64 bits | Alto |
| SDK de Open XML | None | No | Sí | None | Alto |
| EPPlus | None | No | Sí | Ninguna (se requiere licencia comercial para producción) | Medio |
IronXL es compatible tanto con el formato XLS heredado como con el moderno XLSX, no requiere la instalación de controladores del lado del servidor y ofrece la menor complejidad de código de entre las opciones enumeradas. Para los equipos que ya utilizan otros productos de Iron Software, como IronPDF o IronOCR, una única licencia de Iron Software cubre toda la suite.
Completar el ciclo completo —de Excel a una tabla y de vuelta a Excel— es igual de sencillo con IronXL. Este patrón es útil para los botones "descargar como Excel" que permiten a los usuarios exportar lo que se muestra actualmente en la cuadrícula.
void btnExport_Click(object sender, EventArgs e)
{
DataTable dt = Session["CurrentData"] as DataTable;
if (dt == null) return;
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws = workBook.CreateWorkSheet("Export");
// Write header row
for (int col = 0; col < dt.Columns.Count; col++)
ws.SetCellValue(0, col, dt.Columns[col].ColumnName);
// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
for (int col = 0; col < dt.Columns.Count; col++)
ws.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
string exportDir = Server.MapPath("~/Exports/");
Directory.CreateDirectory(exportDir);
string exportPath = Path.Combine(exportDir, "export.xlsx");
workBook.SaveAs(exportPath);
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=export.xlsx");
Response.TransmitFile(exportPath);
Response.End();
}Imports System
Imports System.Data
Imports System.IO
Sub btnExport_Click(sender As Object, e As EventArgs)
Dim dt As DataTable = TryCast(Session("CurrentData"), DataTable)
If dt Is Nothing Then Return
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim ws As WorkSheet = workBook.CreateWorkSheet("Export")
' Write header row
For col As Integer = 0 To dt.Columns.Count - 1
ws.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
ws.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
Next
Next
Dim exportDir As String = Server.MapPath("~/Exports/")
Directory.CreateDirectory(exportDir)
Dim exportPath As String = Path.Combine(exportDir, "export.xlsx")
workBook.SaveAs(exportPath)
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=export.xlsx")
Response.TransmitFile(exportPath)
Response.End()
End SubLa llamada Response.TransmitFile transmite el archivo guardado al navegador, activando un cuadro de diálogo de descarga. El encabezado Content-Disposition: attachment asegura que los navegadores descarguen el archivo en lugar de intentar mostrarlo en línea.
Más allá de los datos sin procesar, IronXL te permite aplicar formato a las celdas antes de guardar. Puede configurar encabezados en negrita, anchos de columna, formatos numéricos y colores de fondo:
// Bold the header row
ws["A1:Z1"].Style.Font.Bold = true;
// Apply a currency format to column C (index 2), rows 2 onward
ws[$"C2:C{dt.Rows.Count + 1}"].FormatString = IronXL.Styles.BuiltinFormats.Accounting2;
// Auto-fit column widths (IronXL approximates based on content length)
ws.AutoSizeColumn(0);
ws.AutoSizeColumn(1);' Bold the header row
ws("A1:Z1").Style.Font.Bold = True
' Apply a currency format to column C (index 2), rows 2 onward
ws($"C2:C{dt.Rows.Count + 1}").FormatString = IronXL.Styles.BuiltinFormats.Accounting2
' Auto-fit column widths (IronXL approximates based on content length)
ws.AutoSizeColumn(0)
ws.AutoSizeColumn(1)Estas llamadas de formateo usan la API de estilo de celda de IronXL, que refleja el modelo de objetos del formato de archivo de Excel sin requerir Interop.
Ahora dispone de un proceso completo y sin controladores para importar archivos de Excel a un GridView de ASP.NET y exportar los datos del GridView de vuelta a Excel utilizando IronXL. Esto es lo que hay que explorar a continuación para seguir construyendo sobre esta base:
Para las aplicaciones .NET Core y ASP.NET Core, la misma API de IronXL funciona tanto en Razor Pages como en controladores MVC. La guía de IronXL ASP.NET Core recorre las diferencias en el manejo de cargas de archivos y patrones de inyección de dependencias.
Empieza con la prueba gratuita de IronXL para probar todas las funciones en tu proyecto antes de comprarlo. No se requiere tarjeta de crédito para la Licencia Trial.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronXL es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
La API de Excel que necesita, sin la molestia de Office Interop.
