¿Cómo puedo abrir un archivo Excel en una aplicación ASP.NET Core?

Puedes abrir un archivo Excel en una aplicación ASP.NET Core usando la biblioteca IronXL. Primero, instala el paquete IronXL a través de NuGet, luego utiliza WorkBook.Load para cargar tu archivo Excel. Puedes acceder a los datos seleccionando la hoja de trabajo e iterando sobre las filas y columnas.

¿Cuáles son los beneficios de usar IronXL sobre Office Interop para manipulación de Excel?

IronXL te permite trabajar con archivos Excel sin necesidad de dependencias de Microsoft Excel o Office Interop, lo que lo hace ideal para entornos de servidor donde instalar Microsoft Office no es factible. Soporta tanto .NET Framework como .NET Core y maneja formatos .XLS y .XLSX.

¿Cómo muestro datos de Excel en una aplicación web usando Páginas Razor?

Para mostrar datos de Excel en una aplicación web, puedes crear una Página Razor que use IronXL para cargar y leer los datos de Excel. Usa un formulario HTML para renderizar los datos de cada celda en campos de entrada de texto, permitiendo a los usuarios ver y editar los datos dentro de la interfaz web.

¿Qué se necesita para configurar un proyecto ASP.NET Core para operaciones con Excel?

Para configurar un proyecto ASP.NET Core para operaciones con Excel, necesitas tener .NET Core 3.1 o superior, un IDE como Microsoft Visual Studio, y un entendimiento básico de ASP.NET Core y Páginas Razor. Instala el paquete IronXL desde NuGet para comenzar a trabajar con archivos Excel.

¿Cómo puedo editar y guardar cambios en un archivo Excel en ASP.NET Core?

Puedes editar y guardar cambios en un archivo Excel permitiendo a los usuarios modificar datos a través de un formulario HTML en una Página Razor. Usa métodos de IronXL como sheet.SetCellValue para actualizar los datos, y workbook.SaveAs para guardar el archivo Excel modificado.

¿Qué pasos están involucrados en la configuración de una Página Razor para operaciones de archivo Excel?

Configurar una Página Razor implica crear una nueva Página Razor en tu proyecto ASP.NET Core. Usa la Página Razor para cargar datos Excel con IronXL, mostrarlo en un formulario web, y manejar envíos de formularios para actualizar y guardar cambios de vuelta al archivo Excel.

¿Cómo soluciono si mi archivo Excel no se carga en ASP.NET Core?

Si tu archivo Excel no se carga, asegúrate de que la ruta del archivo sea correcta y accesible por la aplicación. Verifica que IronXL esté correctamente instalado y que el formato del archivo sea compatible. Revisa si hay excepciones o mensajes de error que puedan indicar cuál es el problema.

¿Puedo probar la biblioteca IronXL antes de comprar?

Sí, IronXL ofrece una versión de prueba gratuita que te permite evaluar sus capacidades. Puedes usar esta prueba para asegurarte de que cumple con tus necesidades antes de decidir comprar una licencia.

How do you ensure data integrity when reading and writing Excel files with IronXL?

By carefully managing exceptions and using methods like `GetCellAt()` and `SetCellValue()`, you maintain data integrity while reading and writing Excel files with IronXL.

What kind of projects is IronXL best suited for?

IronXL is ideal for projects requiring efficient Excel data processing and interaction without extensive dependency setups, such as financial applications or data analysis tools in .NET environments.

La biblioteca de Excel en C#

Explore Biblioteca de hojas de cálculo de Excel de IronXL para C# .NET Prueba gratis

Leer archivos de Excel sin Interop

Ver Todos los Ejemplos de Código %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

USANDO IRONXL

Cómo abrir un archivo de Excel en ASP.NET Core

Curtis Chau

Updated: 21 de abril de 2026

Este tutorial demostrará cómo abrir un archivo de Excel usando IronXL en una aplicación ASP.NET Core utilizando la biblioteca IronXL. Cubrirá los pasos básicos para leer archivos de Excel y luego mostrar datos de ellos y guardar datos modificados de nuevo en el archivo.

¿Qué es IronXL?

IronXL es una biblioteca de .NET Excel que proporciona funcionalidad para trabajar con documentos de Excel sin requerir dependencias de Microsoft Excel o Office Interop. Admite tanto .NET Framework como .NET Core, proporcionando capacidades para escribir, manipular y leer archivos de Excel con solo unas pocas líneas de código. Para un tutorial detallado sobre cómo leer archivos de Excel, por favor consulte este tutorial de Excel.

La biblioteca IronXL puede leer y escribir documentos de Excel, extraer datos de ellos, manipular los datos e incluso crear nuevos archivos de Excel desde cero. IronXL no solo admite el formato .XLS, sino que también es compatible con .XLSX, que es un formato de archivo basado en XML desarrollado por Microsoft para representar hojas de cálculo.

Prerrequisitos

Antes de sumergirse en el código, asegúrese de tener lo siguiente:

Instalado .NET Core 3.1 o superior.
Un IDE adecuado para el desarrollo de .NET (se recomienda Microsoft Visual Studio).
Comprensión básica de ASP.NET Core y Razor Pages.

Crear un nuevo proyecto .NET Core

Abra Microsoft Visual Studio y seleccione "Crear un nuevo proyecto".
Elija "ASP.NET Core Web App" de la lista de plantillas de proyectos y haga clic en "Siguiente".
Proporcione un nombre para su proyecto, por ejemplo, "Open_Excel_File_.NET_Core", seleccione una ubicación y haga clic en "Siguiente".
Elija ".NET Core" como el marco de trabajo de destino y "ASP.NET Core 3.1 o superior" como la versión. En la sección "Plantilla de proyecto", seleccione "Aplicación web" y haga clic en "Crear".

Instalar el paquete IronXL

El siguiente paso es instalar el paquete IronXL en este proyecto recién creado:

Haga clic derecho en el proyecto en el Explorador de soluciones y seleccione "Administrar paquetes NuGet".
En la pestaña "Examinar", busque "IronXL" y haga clic en "Instalar" para el paquete IronXL.Excel.

Cómo abrir un archivo de Excel en ASP .NET Core, Figura 1: Busque e instale el paquete IronXL en la interfaz de usuario de NuGet Package Manager Buscar e instalar el paquete IronXL en la interfaz de usuario del administrador de paquetes NuGet

Espere a que el paquete se instale.

Su proyecto ASP.NET Core ahora está configurado, y la biblioteca IronXL está instalada y lista para usar.

Crear una página de Razor

Ahora, vamos a crear una Página Razor para escribir el código para abrir el archivo de Excel.

Haga clic derecho en la carpeta "Pages" en el Explorador de soluciones y seleccione "Agregar" > "Página Razor".
Ingrese "ExcelOpener" como el nombre de la página y haga clic en "Agregar".

Cómo abrir un archivo de Excel en ASP .NET Core, Figura 2: Crear una nueva página Razor Crear una nueva Página Razor

Esto creará dos archivos: ExcelOpener.cshtml y ExcelOpener.cshtml.cs.

El archivo ExcelOpener.cshtml contiene el marcado HTML para la página, y el archivo ExcelOpener.cshtml.cs contiene el código C# detrás para la página.

Lectura de archivos de Excel

Vamos a sumergirnos en el código. La clase proporcionada ExcelOpenerModel es un modelo de página Razor. Esta clase tiene una propiedad List<List<string>> Data, que se utilizará para almacenar los datos leídos de un archivo de Excel.

public List<List<string>> Data { get; set; }

public ExcelOpenerModel()
{
    Data = new List<List<string>>();
}

public List<List<string>> Data { get; set; }

public ExcelOpenerModel()
{
    Data = new List<List<string>>();
}

Public Property Data() As List(Of List(Of String))

'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public ExcelOpenerModel()
Public Sub New()
	Data = New List(Of List(Of String))()
End Sub

Public Property Data() As List(Of List(Of String))

'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public ExcelOpenerModel()
Public Sub New()
	Data = New List(Of List(Of String))()
End Sub

En el método OnGet, se utiliza IronXL para cargar un archivo de Excel y leer los datos de la hoja de trabajo predeterminada (la primera hoja en el libro de trabajo). Cada fila se representa como una List<string>, y todas estas listas se añaden a la propiedad Data.

public void OnGet()
{
    try
    {
        Data = new List<List<string>>();
        // Load your Excel file
        var workbook = WorkBook.Load(@"C:\Users\Administrator\Documents\Loan.xlsx");

        // Select your Worksheet
        WorkSheet sheet = workbook.DefaultWorkSheet;

        for (int i = 0; i < sheet.RowCount; i++)
        {
            var row = new List<string>();
            for (int j = 0; j < sheet.ColumnCount; j++)
            {
                row.Add(sheet.GetCellAt(i, j).Value.ToString());
            }
            Data.Add(row);
        }
    }
    catch (Exception ex)
    {
        // Handle exceptions here
        Console.WriteLine(ex.Message);
    }
}

public void OnGet()
{
    try
    {
        Data = new List<List<string>>();
        // Load your Excel file
        var workbook = WorkBook.Load(@"C:\Users\Administrator\Documents\Loan.xlsx");

        // Select your Worksheet
        WorkSheet sheet = workbook.DefaultWorkSheet;

        for (int i = 0; i < sheet.RowCount; i++)
        {
            var row = new List<string>();
            for (int j = 0; j < sheet.ColumnCount; j++)
            {
                row.Add(sheet.GetCellAt(i, j).Value.ToString());
            }
            Data.Add(row);
        }
    }
    catch (Exception ex)
    {
        // Handle exceptions here
        Console.WriteLine(ex.Message);
    }
}

Public Sub OnGet()
	Try
		Data = New List(Of List(Of String))()
		' Load your Excel file
		Dim workbook = WorkBook.Load("C:\Users\Administrator\Documents\Loan.xlsx")

		' Select your Worksheet
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet

		For i As Integer = 0 To sheet.RowCount - 1
			Dim row = New List(Of String)()
			For j As Integer = 0 To sheet.ColumnCount - 1
				row.Add(sheet.GetCellAt(i, j).Value.ToString())
			Next j
			Data.Add(row)
		Next i
	Catch ex As Exception
		' Handle exceptions here
		Console.WriteLine(ex.Message)
	End Try
End Sub

Public Sub OnGet()
	Try
		Data = New List(Of List(Of String))()
		' Load your Excel file
		Dim workbook = WorkBook.Load("C:\Users\Administrator\Documents\Loan.xlsx")

		' Select your Worksheet
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet

		For i As Integer = 0 To sheet.RowCount - 1
			Dim row = New List(Of String)()
			For j As Integer = 0 To sheet.ColumnCount - 1
				row.Add(sheet.GetCellAt(i, j).Value.ToString())
			Next j
			Data.Add(row)
		Next i
	Catch ex As Exception
		' Handle exceptions here
		Console.WriteLine(ex.Message)
	End Try
End Sub

Métodos clave explicados

WorkBook.Load(filepath): Este método carga el documento de Excel desde la ruta de archivo especificada. Ayuda a cargar y leer la hoja de Excel.
workbook.DefaultWorkSheet: Esta propiedad obtiene la hoja de trabajo de Excel predeterminada (primera) en la hoja de cálculo de Excel.
sheet.GetCellAt(i, j).Value.ToString(): Esto obtiene la celda en los índices de fila y columna especificados y convierte su valor a una cadena. Este es un ejemplo de un método de índice que puede acceder a celdas específicas o rangos dentro de un archivo Excel basado en índices de fila y columna.

Breve explicación

En el archivo ExcelOpener.cshtml.cs, una clase llamada ExcelOpenerModel representa el modelo de página Razor. Contiene una propiedad llamada Data de tipo List<List<string>>, que contendrá los datos del archivo de Excel.

El método OnGet se llama cuando se solicita la página y es responsable de leer los datos del archivo de Excel. Utiliza IronXL para cargar el archivo de Excel, selecciona la hoja de trabajo predeterminada y recorre las filas y columnas para llenar la propiedad Data.

Escribir archivos de Excel

El método OnPost en la clase ExcelOpenerModel se utiliza para guardar modificaciones en el archivo de Excel. Primero carga el archivo de Excel y recupera la hoja de trabajo predeterminada. Luego escribe los valores de Data en las celdas de la hoja de trabajo y guarda el libro en un nuevo archivo.

public void OnPost()
{
    try
    {
        // Load your Excel file
        var workbook = WorkBook.Load(@"C:\Users\Administrator\Documents\Loan.xlsx");

        // Select your Worksheet
        var sheet = workbook.DefaultWorkSheet;

        for (int i = 0; i < Data.Count; i++)
        {
            for (int j = 0; j < Data[i].Count; j++)
            {
                sheet.SetCellValue(i, j, Data[i][j]);
            }
        }

        // Save the Excel file
        var filename = @"C:\ModifiedData.xlsx";
        workbook.SaveAs(filename);
    }
    catch (Exception ex)
    {
        // Handle exceptions here
        Console.WriteLine(ex.Message);
    }
}

public void OnPost()
{
    try
    {
        // Load your Excel file
        var workbook = WorkBook.Load(@"C:\Users\Administrator\Documents\Loan.xlsx");

        // Select your Worksheet
        var sheet = workbook.DefaultWorkSheet;

        for (int i = 0; i < Data.Count; i++)
        {
            for (int j = 0; j < Data[i].Count; j++)
            {
                sheet.SetCellValue(i, j, Data[i][j]);
            }
        }

        // Save the Excel file
        var filename = @"C:\ModifiedData.xlsx";
        workbook.SaveAs(filename);
    }
    catch (Exception ex)
    {
        // Handle exceptions here
        Console.WriteLine(ex.Message);
    }
}

Public Sub OnPost()
	Try
		' Load your Excel file
		Dim workbook = WorkBook.Load("C:\Users\Administrator\Documents\Loan.xlsx")

		' Select your Worksheet
		Dim sheet = workbook.DefaultWorkSheet

		For i As Integer = 0 To Data.Count - 1
			Dim j As Integer = 0
			Do While j < Data(i).Count
				sheet.SetCellValue(i, j, Data(i)(j))
				j += 1
			Loop
		Next i

		' Save the Excel file
		Dim filename = "C:\ModifiedData.xlsx"
		workbook.SaveAs(filename)
	Catch ex As Exception
		' Handle exceptions here
		Console.WriteLine(ex.Message)
	End Try
End Sub

Public Sub OnPost()
	Try
		' Load your Excel file
		Dim workbook = WorkBook.Load("C:\Users\Administrator\Documents\Loan.xlsx")

		' Select your Worksheet
		Dim sheet = workbook.DefaultWorkSheet

		For i As Integer = 0 To Data.Count - 1
			Dim j As Integer = 0
			Do While j < Data(i).Count
				sheet.SetCellValue(i, j, Data(i)(j))
				j += 1
			Loop
		Next i

		' Save the Excel file
		Dim filename = "C:\ModifiedData.xlsx"
		workbook.SaveAs(filename)
	Catch ex As Exception
		' Handle exceptions here
		Console.WriteLine(ex.Message)
	End Try
End Sub

Métodos clave explicados

sheet.SetCellValue(i, j, Data[i][j]): Este método asigna el valor de la celda en los índices de fila y columna especificados.
workbook.SaveAs(filepath): Este método guarda el libro de trabajo de Excel en la ruta de archivo especificada.

Breve explicación

El método OnPost se llama cuando se envía el formulario, y guarda los datos modificados de nuevo en el archivo de Excel. Carga el archivo de Excel, selecciona la hoja de trabajo predeterminada y actualiza los valores de las celdas según los datos modificados recibidos del formulario.

Formulario HTML para editar datos de Excel

En ExcelOpener.cshtml, se define un formulario para mostrar y editar los datos del archivo de Excel. Cada valor de celda se muestra en un campo de entrada de texto. Después de editar, al hacer clic en el botón "Ahorra" se enviará el formulario, desencadenará el método OnPost y guardará los cambios en el archivo de Excel.

@page
@model Open_Excel_File_.NET_Core.Pages.ExcelOpenerModel

<form method="post">
    <table class="table table-bordered table-striped">
        <!-- Bootstrap classes for tables -->
        @for (int i = 0; i < Model.Data.Count; i++)
        {
            <tr>
                @for (int j = 0; j < Model.Data[i].Count; j++)
                {
                    <td>
                        <input type="text" class="form-control" name="Data[@i][@j]" value="@Model.Data[i][j]" /> <!-- Bootstrap class for form controls -->
                    </td>
                }
            </tr>
        }
    </table>

    <input type="submit" class="btn btn-primary" value="Save" /> <!-- Bootstrap classes for buttons -->
</form>

@page
@model Open_Excel_File_.NET_Core.Pages.ExcelOpenerModel

<form method="post">
    <table class="table table-bordered table-striped">
        <!-- Bootstrap classes for tables -->
        @for (int i = 0; i < Model.Data.Count; i++)
        {
            <tr>
                @for (int j = 0; j < Model.Data[i].Count; j++)
                {
                    <td>
                        <input type="text" class="form-control" name="Data[@i][@j]" value="@Model.Data[i][j]" /> <!-- Bootstrap class for form controls -->
                    </td>
                }
            </tr>
        }
    </table>

    <input type="submit" class="btn btn-primary" value="Save" /> <!-- Bootstrap classes for buttons -->
</form>

HTML

Navegando a la página

En _Layout.cshtml, se añade un enlace a la página en el menú de navegación. Haciendo clic en este enlace, navegará a la página de apertura de Excel.

<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-page="/ExcelOpener">ExcelOpener</a>
</li>

<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-page="/ExcelOpener">ExcelOpener</a>
</li>

HTML

Ejecutar la aplicación y explicar el resultado

Compila la aplicación haciendo clic en el botón "Compilar" en Visual Studio o utilizando el atajo Ctrl + Shift + B. Ejecute la aplicación presionando F5 o haciendo clic en el botón "Iniciar" en Visual Studio.

Una vez que la aplicación esté en ejecución, navegue a la página "ExcelOpener" haciendo clic en el enlace correspondiente en la barra de navegación. La página mostrará los datos de Excel en formato tabular.

Puede modificar los datos en la tabla y hacer clic en el botón "Guardar" para guardar los cambios de nuevo en el archivo de Excel.

Cómo abrir un archivo de Excel en ASP .NET Core, Figura 3: Mostrar datos de Excel en la aplicación web Mostrar datos de Excel en la aplicación web

Este tutorial demostró cómo abrir un archivo de Excel usando IronXL en una aplicación ASP.NET Core. IronXL proporciona una forma simple y conveniente de leer y manipular archivos de Excel. Puede explorar la documentación de IronXL para características y funcionalidades más avanzadas.

IronXL ofrece una prueba gratuita, permitiéndole evaluar sus capacidades. Si lo encuentra útil para sus proyectos, puede adquirir una licencia comenzando desde $999.

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 estructurados y visualmente atractivos.

...