Una comparación entre IronXL y GrapeCity Excel Viewer

¿Qué te ofrece GrapeCity Documents for Excel?

• Permite la creación, manipulación y serialización de hojas de cálculo en el servidor.
• Baja huella de memoria.
• Realiza cálculos complejos utilizando el potente motor de cálculo.
• Documento de alta velocidad intuitivo; inteligencia de negocios integrada.
• Proporciona soluciones de informes completas.
• Te da control total de tus documentos a alta velocidad.
• Genera salidas en una variedad de formatos, incluidos .xlsx y ssjson.
• Soporte para .NET Framework, .NET Core y Mono en varias plataformas.
• Compatible con WinForms, WPF, ASP.NET y otros entornos.

GrapeCity Excel: características destacadas

La última versión 14.1 tiene muchas características nuevas y emocionantes.

• Arquitectura API de hoja de cálculo ligera para una eficiencia mejorada

GcExcel .NET permite a los usuarios ahorrar una cantidad considerable de tiempo, memoria de almacenamiento y esfuerzo al mejorar la eficiencia general con su arquitectura API ligera que se puede utilizar para generar, cargar, editar, guardar y convertir hojas de cálculo.

• Sin dependencia de MS Excel

Para trabajar con GcExcel .NET, los usuarios no necesitan instalar la Suite de MS Office ni acceder a MS Excel en sus sistemas.

• Crea una experiencia interactiva con SpreadJS DSheets

GcExcel .NET se puede utilizar con hojas de cálculo para una experiencia completamente interactiva y fácil de usar.

• Despliega aplicaciones con hojas de cálculo de Excel en la nube

Con GcExcel .NET, puedes aplicar implementaciones basadas en la nube y desplegar tus aplicaciones en Azure y AWS Lambda.

• Formas e Imágenes

Con la API de hoja de cálculo, puedes insertar y personalizar formas e imágenes en las celdas de una hoja de trabajo, aplicar formato, relleno degradado, configurar texto, insertar hipervínculos, establecer puntos de ajuste de las formas, agrupar/desagruparlas en una hoja de trabajo y determinar la posición y tamaño de una imagen.

Conjunto de características de IronXL

• Cargar, Leer y Editar Datos — desde XLS/XLSX/CSV/TSV
• Guardar y Exportar — a XLS/XLSX/CSV/TSV/JSON
• Objetos System.Data — Trabaja con hojas de cálculo de Excel como objetos System.Data.DataSet y System.Data.DataTable.
• Fórmulas — trabaja con fórmulas de Excel. Las fórmulas se recalculan cada vez que se edita una hoja.
• Rangos — Sintaxis fácil de usar WorkSheet ["A1:B10"]. Combina y crea rangos de manera intuitiva.
• Ordenación — Ordena rangos, columnas y filas.
• Estilización — Estilos visuales de celdas, fuente, tamaño, patrón de fondo, borde, alineación y formatos numéricos.

Uso de Visual Studio con paquetes NuGet

Visual Studio proporciona el Administrador de Paquetes NuGet para instalar paquetes NuGet en tus proyectos. Puedes acceder a él a través del menú Proyecto, o haciendo clic derecho en tu proyecto en el Explorador de Soluciones.

• A continuación, desde la pestaña Explorar -> busca IronXL.Excel -> Instalar

• Y hemos terminado.

Uso de la consola del administrador de paquetes NuGet

Otra forma de descargar e instalar la biblioteca C# Microsoft.Office.Interop.Excel es seguir los siguientes pasos para instalar el paquete NuGet a través del Símbolo del sistema de desarrollo.

• Abre el Símbolo del sistema del desarrollador, generalmente encontrado en la carpeta de Visual Studio.
• Escribe el siguiente comando:

Install-Package Microsoft.Office.Interop.Excel

• Presiona Enter.
• Esto descargará e instalará el paquete.
• Recarga tu proyecto de Visual Studio y comienza a usarlo.

Añadir directivas using necesarias

1. En el Explorador de Soluciones, haz clic derecho en el archivo Program.cs y luego haz clic en Ver Código.
2. Añade las siguientes directivas de uso en la parte superior del archivo de código:

using Excel = Microsoft.Office.Interop.Excel;

using Excel = Microsoft.Office.Interop.Excel;

Imports Excel = Microsoft.Office.Interop.Excel

Creación de archivos Excel con IronXL

No podría ser más fácil crear un nuevo libro de Excel usando IronXL. ¡Solo una línea de código! Sí, de verdad. Añade el siguiente código a tu función de vacío estática principal en el archivo Program.cs:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Con IronXL se pueden crear tanto formatos de archivo XLS (versión anterior de archivos de Excel) como XLSX (versión actual y más reciente).

Y, es aún más fácil crear una Hoja de Trabajo predeterminada:

var worksheet = workbook.CreateWorkSheet("IronXL Features");

var worksheet = workbook.CreateWorkSheet("IronXL Features");

Dim worksheet = workbook.CreateWorkSheet("IronXL Features")

Ahora puedes utilizar la variable de la hoja de trabajo para establecer valores de celda y hacer prácticamente cualquier cosa que pueda hacer un archivo de Excel.

Creación de archivos de Excel mediante una API de Excel del lado del servidor GrapeCity Excel

GrapeCity Documents para Excel (o GcExcel) es una API de Excel del lado del servidor que te permite crear, cargar, guardar, convertir, calcular, formatear, analizar y exportar hojas de cálculo en cualquier aplicación .NET Standard. GcExcel puede desplegarse en Azure sin ninguna dependencia de Excel gracias al soporte completo de .NET5 para Windows, Linux y Mac.

GcExcel te permite crear y generar hojas de cálculo de Excel del lado del servidor sin tener que usar MS Excel.

• Crea un libro de trabajo con GcExcel en una función.
• Regresa al cliente después de convertir el libro de trabajo a JSON.

En este ejemplo, solo vamos a hacer una hoja de cálculo BidTracker.xlsx. Esta muestra muestra funcionalidad adicional del lado del servidor que puede programarse con GcExcel.

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
    Workbook workbook = CreateWorkbookByCaseName(caseName);
    var ssjson = workbook.ToJson();
    return Ok(ssjson);
}

private Workbook CreateWorkbookByCaseName(string caseName)
{
    switch (caseName)
    {
        case "BidTracker":
            return GetBidTracker();
        default:
            break;
    }

    return new Workbook();
}

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
    Workbook workbook = CreateWorkbookByCaseName(caseName);
    var ssjson = workbook.ToJson();
    return Ok(ssjson);
}

private Workbook CreateWorkbookByCaseName(string caseName)
{
    switch (caseName)
    {
        case "BidTracker":
            return GetBidTracker();
        default:
            break;
    }

    return new Workbook();
}

<HttpGet("{caseName}")>
Public Function GetSSJsonFromUseCase(ByVal caseName As String) As IActionResult
	Dim workbook As Workbook = CreateWorkbookByCaseName(caseName)
	Dim ssjson = workbook.ToJson()
	Return Ok(ssjson)
End Function

Private Function CreateWorkbookByCaseName(ByVal caseName As String) As Workbook
	Select Case caseName
		Case "BidTracker"
			Return GetBidTracker()
		Case Else
	End Select

	Return New Workbook()
End Function

Editar archivos de Excel con GrapeCity Excel

Comencemos a usar GcExcel para abordar estos problemas.

Te entregan una hoja de cálculo que se ve así:

Primero, querremos formatear la hoja:

• Cambia las propiedades de la fuente del título de la hoja y la celda de Ingresos Totales.
• Cambia los estilos de tabla, columna de tabla y celda.

Echemos un vistazo a cómo lograr esto usando GcExcel.

Paso 1: Cargar una hoja de cálculo de Excel existente

Escribe el siguiente código para cargar una hoja de cálculo existente en tu Libro de Trabajo de GcExcel:

Workbook workbook = new Workbook();
workbook.Open("EventBudget.xlsx");

Workbook workbook = new Workbook();
workbook.Open("EventBudget.xlsx");

Dim workbook As New Workbook()
workbook.Open("EventBudget.xlsx")

Paso 2: Obtener la hoja de trabajo que deseas modificar

IWorksheet worksheet = workbook.ActiveWorksheet;

IWorksheet worksheet = workbook.ActiveWorksheet;

Dim worksheet As IWorksheet = workbook.ActiveWorksheet

Paso 3: Modificar las propiedades de la fuente de los títulos

Cambiar las propiedades de la fuente de las celdas B2 (tamaño de fuente) y E4 (establecer en negrita):

// Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22;

// Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = true;

// Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22;

// Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = true;

' Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22

' Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = True

Paso 4: Modificar el estilo de la tabla

Establecer estilos de las cuatro tablas a un estilo incorporado.

worksheet.Tables["tblAdmissions"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblAds"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblVendors"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblItems"].TableStyle = workbook.TableStyles["TableStyleLight10"];

worksheet.Tables["tblAdmissions"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblAds"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblVendors"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblItems"].TableStyle = workbook.TableStyles["TableStyleLight10"];

worksheet.Tables("tblAdmissions").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblAds").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblVendors").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblItems").TableStyle = workbook.TableStyles("TableStyleLight10")

Paso 5: Modificar estilo de rango de celdas

Modificar el estilo de celda de las celdas de Ingresos Totales. La propiedad Interior de un rango puede ayudarte a establecer las propiedades ThemeColor y TintAndShade. También se puede cambiar la fuente de todo el rango utilizando la propiedad Font. Además, este código puede establecer los bordes de un rango de celdas.

Dado que la hoja de cálculo muestra los datos del presupuesto, establece el formato numérico de un rango de celdas a moneda.

// Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15;
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major;
worksheet.GetRange("F4:G5").Font.Size = 12;
worksheet.GetRange("F4:G5").Borders[BordersIndex.InsideHorizontal].LineStyle = BorderLineStyle.None;
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00";

// Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15;
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major;
worksheet.GetRange("F4:G5").Font.Size = 12;
worksheet.GetRange("F4:G5").Borders[BordersIndex.InsideHorizontal].LineStyle = BorderLineStyle.None;
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00";

' Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major
worksheet.GetRange("F4:G5").Font.Size = 12
worksheet.GetRange("F4:G5").Borders(BordersIndex.InsideHorizontal).LineStyle = BorderLineStyle.None
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00"

Paso 6: Modificar estilos de columna de tabla

Como los rangos de columna de tabla son diferentes, establece las propiedades ThemeColor, TintAndShade y NumberFormat en un rango de columna diferente de la tabla.

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15;
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00";

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15;
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00";

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00"

Paso 7: Guardar el archivo de Excel

// Save to an Excel file
workbook.Save("EventBudget.xlsx");

// Save to an Excel file
workbook.Save("EventBudget.xlsx");

' Save to an Excel file
workbook.Save("EventBudget.xlsx")

¡Felicitaciones! Has cambiado completamente el formato del documento. Ejecuta la aplicación y tu hoja de cálculo de Excel se verá así:

Editar archivos de Excel con IronXL

Una vez que hayas instalado IronXL, abordemos el proceso de edición de archivos de Excel con él.

Editar los Valores de Celdas Específicas

Primero, veremos cómo cambiar los valores de ciertas celdas en una hoja de cálculo de Excel.

Hacemos esto importando la hoja de cálculo de Excel que debe cambiarse y accediendo a su Hoja de Trabajo. Luego, podemos hacer los cambios como se indica a continuación.

using IronXL;

static void Main(string[] args)
{
    // Import Excel Spreadsheet
    WorkBook wb = WorkBook.Load("sample.xlsx");

    // Access specific worksheet
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Access specific cell and modify its value
    ws.Rows[3].Columns[1].Value = "New Value";

    // Save changes
    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    // Import Excel Spreadsheet
    WorkBook wb = WorkBook.Load("sample.xlsx");

    // Access specific worksheet
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Access specific cell and modify its value
    ws.Rows[3].Columns[1].Value = "New Value";

    // Save changes
    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	' Import Excel Spreadsheet
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")

	' Access specific worksheet
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Access specific cell and modify its value
	ws.Rows(3).Columns(1).Value = "New Value"

	' Save changes
	wb.SaveAs("sample.xlsx")
End Sub

Aquí hay capturas de pantalla antes y después de la muestra de hoja de cálculo sample.xlsx:

Podemos ver lo simple que es modificar el valor de la hoja de cálculo de Excel.

Si es necesario, también hay una forma alternativa de editar el valor de la celda específica por dirección de celda:

// Alternative way to access specific cell and apply changes
ws["B4"].Value = "New Value";

// Alternative way to access specific cell and apply changes
ws["B4"].Value = "New Value";

' Alternative way to access specific cell and apply changes
ws("B4").Value = "New Value"

Editar Valores de Fila Completa

Es bastante simple editar valores de fila completa de una hoja de cálculo de Excel con un valor estático.

using IronXL;

static void Main(string[] args)
{    
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full row value
    ws.Rows[3].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{    
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full row value
    ws.Rows[3].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Set full row value
	ws.Rows(3).Value = "New Value"

	wb.SaveAs("sample.xlsx")
End Sub

Ve las capturas de pantalla de la muestra sample.xlsx a continuación:

Para esto, también podemos editar el valor de un rango específico de la fila usando la función de rango:

// Modify specific range within a row
ws["A3:E3"].Value = "New Value";

// Modify specific range within a row
ws["A3:E3"].Value = "New Value";

' Modify specific range within a row
ws("A3:E3").Value = "New Value"

Editar Valores de Columna Completa

De la misma manera que arriba, podemos editar fácilmente columnas completas de la hoja de cálculo de Excel con un solo valor.

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full column value
    ws.Columns[1].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full column value
    ws.Columns[1].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Set full column value
	ws.Columns(1).Value = "New Value"

	wb.SaveAs("sample.xlsx")
End Sub

Esto producirá nuestra hoja de cálculo sample.xlsx como tal:

Editar Filas Completas con Valores Dinámicos

Usando IronXL, también es posible editar filas específicas con valores dinámicos. Esto significa que podemos editar una fila completa asignando valores dinámicos a cada celda. Echemos un vistazo al ejemplo:

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Columns.Count(); i++)
    {
        // Set cell value dynamically based on column index
        ws.Rows[3].Columns[i].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Columns.Count(); i++)
    {
        // Set cell value dynamically based on column index
        ws.Rows[3].Columns[i].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	For i As Integer = 0 To ws.Columns.Count() - 1
		' Set cell value dynamically based on column index
		ws.Rows(3).Columns(i).Value = "New Value " & i.ToString()
	Next i

	wb.SaveAs("sample.xlsx")
End Sub

En la tabla a continuación, podemos ver las capturas de pantalla de la hoja de cálculo sample.xlsx de este resultado:

Editar Columnas Completas con Valores Dinámicos

También es fácil editar columnas específicas con valores dinámicos.

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Rows.Count(); i++)
    {
        // Skip header row
        if (i == 0) continue;

        // Set cell value dynamically based on row index
        ws.Rows[i].Columns[1].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Rows.Count(); i++)
    {
        // Skip header row
        if (i == 0) continue;

        // Set cell value dynamically based on row index
        ws.Rows[i].Columns[1].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	For i As Integer = 0 To ws.Rows.Count() - 1
		' Skip header row
		If i = 0 Then
			Continue For
		End If

		' Set cell value dynamically based on row index
		ws.Rows(i).Columns(1).Value = "New Value " & i.ToString()
	Next i

	wb.SaveAs("sample.xlsx")
End Sub

Con los resultados de la tabla de sample.xlsx a continuación:

Usar GrapeCity para convertir hojas de cálculo a PDF

GrapeCity Documents para Excel, Edición Java (GcExcel Java) es una API de hoja de cálculo de alta velocidad y pequeño tamaño que no requiere dependencias en Excel. Con soporte total en Windows, Linux y Mac, puedes generar, cargar, modificar y guardar hojas de cálculo, luego convertirlas a PDF.

Aquí están los tres pasos para convertir hojas de cálculo a PDF en aplicaciones Java:

1. Cargar una hoja de cálculo de Excel existente en un libro de trabajo GcExcel
2. Añadir PDFBox como una librería
3. Convertir la hoja de cálculo a PDF

Paso 1: Cargar una hoja de cálculo de Excel existente en un libro de trabajo GcExcel

Crea un objeto de libro de trabajo GcExcel y carga una hoja de cálculo existente.

Workbook workbook = new Workbook();
workbook.Open("FinancialKPI.xlsx");

Workbook workbook = new Workbook();
workbook.Open("FinancialKPI.xlsx");

Dim workbook As New Workbook()
workbook.Open("FinancialKPI.xlsx")

Paso 2: Añadir PDFBox como librería

GcExcel Java referencia a PDFBox para convertir hojas de cálculo en PDF. PDFBox también depende de los paquetes FontBox y Commons Logging.

Siguiendo estos pasos podrás añadir estos archivos JAR como una librería a tu proyecto:

1. Descarga el paquete — Archivos JAR PDFBox, FontBox, Commons Loggings.
2. Bajo la carpeta 'src' en el proyecto, añade una carpeta 'libs'.
3. Copia los tres archivos JAR a la carpeta 'libs'.
4. Haz clic derecho en la carpeta 'libs' y elige la opción 'Añadir como librería'.
5. Presiona OK.

Nota: Los pasos anteriores serían necesarios solo si el proyecto es un proyecto consola Java original. Si el proyecto es un proyecto Maven o Gradle, solo agregar la dependencia de GcExcel Java sería suficiente. Maven o Gradle descargarán e instalarán automáticamente todos los JARs dependientes.

En algunas versiones de Maven, puedes obtener un error de dependencia al añadir los archivos JAR anteriores. Para resolver eso, por favor añade el siguiente nodo antes de las dependencias en pom.xml:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.felix</groupId>
            <artifactId>maven-bundle-plugin</artifactId>
            <extensions>true</extensions>
        </plugin>
    </plugins>
</build>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.felix</groupId>
            <artifactId>maven-bundle-plugin</artifactId>
            <extensions>true</extensions>
        </plugin>
    </plugins>
</build>

Paso 3: Convertir la hoja de cálculo a PDF

Guarda la hoja de cálculo como PDF utilizando el siguiente código:

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf)

Tu PDF se verá así:

Uso de IronXL para convertir hojas de cálculo a XML y JSON

El siguiente código demuestra cómo exportar un archivo de Excel a un archivo XML o JSON con IronXL. Agrega el siguiente código:

Incluye el espacio de nombres:

using IronXL;

using IronXL;

Imports IronXL

Añade las siguientes líneas:

private void ExportToXmlJson()
{        
    WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");

    // Export to JSON
    workbook.SaveAsJson("IronXL_Output.json");

    // Export to XML
    workbook.SaveAsXml("IronXL_Output.xml");
}

private void ExportToXmlJson()
{        
    WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");

    // Export to JSON
    workbook.SaveAsJson("IronXL_Output.json");

    // Export to XML
    workbook.SaveAsXml("IronXL_Output.xml");
}

Private Sub ExportToXmlJson()
	Dim workbook As WorkBook = WorkBook.Load("IronXL_Output.xlsx")

	' Export to JSON
	workbook.SaveAsJson("IronXL_Output.json")

	' Export to XML
	workbook.SaveAsXml("IronXL_Output.xml")
End Sub

Aquí, se carga un objeto de Libro de Excel existente y luego se exporta a los formatos JSON y XML.

Licencias y precios de IronXL

IronXL es una biblioteca de Excel en C# comercial abiertamente. Es gratis para desarrollo y siempre se puede obtener una licencia para despliegue comercial. Las licencias se ofrecen para uso de un solo proyecto, un solo desarrollador, agencias y organizaciones multinacionales, así como para distribución SaaS y OEM. Todas las licencias contienen una garantía de devolución de dinero de 30 días, un año de soporte y actualizaciones de software, validez para dev/staging/producción, y también una licencia permanente (una compra única). El paquete Lite empieza a partir de $799.

Licencias y precios de GrapeCity