Í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#

Curtis Chau
Curtis Chau
Actualizado:

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.

¿Cómo se instala IronXL para la integración de GridView en Excel?

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.

Install-Package IronXL.Excel

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;
using IronXL;
using System.Data;
using System.IO;
Imports IronXL
Imports System.Data
Imports System.IO
$vbLabelText   $csharpLabel

IronXL 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.

¿Por qué evitar OLEDB para el enlace de datos de GridView?

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.

¿A qué plataformas .NET se dirige IronXL?

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.

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

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();
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()
$vbLabelText   $csharpLabel

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.

¿Cómo gestiona ToDataTable los tipos de datos mixtos?

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.

¿Cómo se crea una página de formularios web ASP.NET para importar Excel?

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

:

<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" />
<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" />
$vbLabelText   $csharpLabel

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;
}
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 Sub
$vbLabelText   $csharpLabel

Esta 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.

Importar Excel a GridView en ASP.NET C# con IronXL: Datos de la hoja de cálculo cargados y representados en un control GridView

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.

¿Cómo se debe validar el archivo cargado?

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;
}
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 If
$vbLabelText   $csharpLabel

Tambié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.

¿Cómo se accede a hojas de cálculo y rangos de celdas específicos?

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();
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()
$vbLabelText   $csharpLabel

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.

Importar Excel a GridView en ASP.NET C# con IronXL: Datos de hoja de cálculo nombrados vinculados a un GridView

¿Cómo se filtran las filas antes de vincularlas a GridView?

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();
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()
$vbLabelText   $csharpLabel

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.

¿Cómo se comparan los métodos de importación para el enlace de Excel GridView?

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.

Comparación de métodos de importación de Excel para el enlace de GridView en ASP.NET
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.

¿Cómo se exportan los datos de GridView de vuelta a Excel?

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();
}
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 Sub
$vbLabelText   $csharpLabel

La 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.

Importar Excel a GridView en ASP.NET C# con IronXL: DataTable exportado de nuevo a un archivo Excel

¿Cuáles son las opciones de formato habituales de IronXL para las exportaciones?

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);
' 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)
$vbLabelText   $csharpLabel

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.

¿Cuales son tus próximos pasos?

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.

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.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

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

Leer más

Artículos Relacionados

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

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame