Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Blog sobre generar Excel C#
USANDO IRONXL

IronXL para generar Excel SII/AEAT en C#: guía completa para desarrolladores de compliance fiscal

Curtis Chau
Curtis Chau
Actualizado:

La generación de hojas de cálculo de Excel mediante programación en C# solía requerir la instalación de Microsoft Office o una compleja interoperabilidad COM. IronXL cambia esto por completo, ofreciendo una sencilla API que crea archivos de Excel sin ninguna dependencia de Office. Para los desarrolladores de aplicaciones de compliance fiscal en España, esto tiene una implicación directa: los servicios que generan ficheros XLSX para el SII (Suministro Inmediato de Información) de la AEAT, para los modelos 303, 347 y 390, para VeriFactu (Real Decreto-Ley 15/2025) o para las remisiones al Banco de España corren habitualmente en servidores Linux o contenedores Docker sin licencia Office. Este tutorial te guía para construir archivos de Excel en C# usando IronXL —la librería Excel C# SII AEAT de referencia para desarrolladores de compliance fiscal en España—, desde la creación básica de hojas de cálculo hasta el formato avanzado y la integración de bases de datos.

Cómo Generar Archivo Excel en C# Usando IronXL: Imagen 1 - IronXL

¿Por qué IronXL es la solución para generar Excel SII/AEAT en C# sin Office?

Desarrollar funciones de generación de Excel sin las dependencias de Office resuelve problemas críticos de implementación. Los entornos de servidor rara vez tienen Microsoft Office instalado debido a los costos de licencias y la sobrecarga de recursos. Cada instalación de Office requiere un espacio en disco y memoria significativos, lo que lo hace poco práctico para implementaciones en la nube o aplicaciones contenedorizadas.

Para los desarrolladores de compliance fiscal en España, este escenario es cotidiano: el servicio de integración con el SII debe generar el XML de facturas y también el XLSX de auditoría interna con el libro registro; el sistema de TicketBAI en Bizkaia, Gipuzkoa y Araba necesita exportar datos a XLSX para verificación; los informes del modelo 303 requieren XLSX con bases imponibles y cuotas trimestrales. Ninguno de estos entornos puede depender de Office.

IronXL elimina estas limitaciones al funcionar de forma independiente. Tu generación de archivos de Excel en C# se ejecuta en Windows, Linux, macOS, contenedores de Docker, o Azure App Services sin modificaciones. Esta compatibilidad multiplataforma significa que se escribe una vez y se implementa en cualquier lugar, ya sea para aplicaciones de .NET Framework, .NET Core o .NET 10.

Cómo Generar Archivo Excel en C# Usando IronXL: Imagen 2 - Plataforma Cruzada

El rendimiento mejora drásticamente sin la sobrecarga de la interoperabilidad COM. La automatización tradicional de Office crea instancias de proceso separadas para cada operación, consumiendo memoria y recursos de CPU. IronXL procesa todo en memoria dentro del espacio de proceso de su aplicación, lo que se traduce en una ejecución más rápida y un menor consumo de recursos al generar archivos Excel mediante programación.

La implementación se vuelve sencilla ya que IronXL se entrega como un único paquete NuGet. Sin entradas en el Registro, sin registro COM y sin paquetes de servicio de Office que mantener. Tus procesos de integración continua funcionan sin problemas y los contenedores Docker siguen siendo ligeros. Este enfoque simplificado ha hecho de IronXL una elección popular, según se discute en varios foros de desarrolladores donde los profesionales comparten sus experiencias con la automatización de Excel.

Algunos desarrolladores siguen explorando la herramienta Open XML Productivity Tool de Microsoft para trabajar directamente con estructuras de archivos Office Open XML. Aún así, ese enfoque requiere más esfuerzo manual y un conocimiento detallado del esquema XML y la instalación del SDK de Open XML. IronXL abstrae estas complejidades, ofreciéndole un camino mucho más rápido para trabajar con Excel mediante programación.

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 3 - Características

¿Cómo instalar IronXL en un proyecto C# de compliance fiscal?

La instalación de IronXL se realiza en unos instantes a través del Gestor de paquetes NuGet en Visual Studio. Haga clic con el botón derecho del ratón en su proyecto en el Explorador de soluciones y seleccione "Administrar paquetes NuGet". Busque "IronXL.Excel" y haga clic en Instalar. El paquete incluye automáticamente todas las dependencias necesarias para generar archivos de Excel en C#.

Para instalarlo a través de la Consola del Administrador de paquetes o la CLI de .NET, utilice cualquiera de los siguientes comandos:

Install-Package IronXL.Excel
dotnet add package IronXL.Excel
Install-Package IronXL.Excel
dotnet add package IronXL.Excel
SHELL

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 4 - Instalación

Comprueba la instalación con esta sencilla prueba para confirmar que la biblioteca está lista:

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");
using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");
Imports IronXL

' Create an in-memory workbook
Dim workbook = WorkBook.Create()
Console.WriteLine("IronXL installed successfully!")
$vbLabelText   $csharpLabel

Si esto se ejecuta sin errores, IronXL está listo para su uso. La biblioteca es compatible con todas las versiones modernas de .NET, asegurando la compatibilidad con tus proyectos existentes. Para obtener instrucciones detalladas sobre la instalación y la resolución de problemas, consulte la documentación oficial de instalación de NuGet.

Resultado

Cómo Generar Archivo Excel en C# Usando IronXL: Imagen 5 - Salida de Consola

¿Cómo se crea el primer fichero XLSX para compliance AEAT?

La creación de archivos Excel con IronXL comienza con la clase WorkBook, tu puerta de entrada a todas las operaciones de Excel. La biblioteca es compatible tanto con el formato moderno XLSX como con el formato heredado XLS, lo que te ofrece flexibilidad para diferentes requisitos. A continuación se muestra un ejemplo orientado a la generación de un fichero de declaración del modelo 303 de IVA trimestral:

using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add header row
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");
using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add header row
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");
Imports IronXL

' Create a new workbook (XLSX format by default)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

' Add metadata
workbook.Metadata.Title = "Monthly Sales Report"
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Comments = "Generated using IronXL"

' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("January Sales")

' Add header row
worksheet("A1").Value = "Date"
worksheet("B1").Value = "Product"
worksheet("C1").Value = "Quantity"
worksheet("D1").Value = "Revenue"

' Add data rows
worksheet("A2").Value = New DateTime(2024, 1, 15)
worksheet("B2").Value = "Widget Pro"
worksheet("C2").Value = 100
worksheet("D2").Value = 2500.0

' Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx")
$vbLabelText   $csharpLabel

Este código demuestra varios conceptos clave para la generación de archivos de Excel. El método WorkBook.Create() inicializa un nuevo archivo Excel en memoria. Especifique el formato utilizando el enum ExcelFileFormat: elija XLSX para compatibilidad con Excel moderno o XLS para compatibilidad con versiones anteriores. La propiedad Metadata permite incrustar información de documentos que aparece en las propiedades de archivo de Excel, siguiendo los estándares de propiedades de documentos de Microsoft.

El método CreateWorkSheet() añade una nueva hoja con el nombre especificado. La notación de celda familiar de Excel (A1, B1, etc.) hace que establecer valores sea intuitivo. IronXL maneja automáticamente la conversión de tipos de datos, reconociendo fechas, números y texto sin casting explícito. El método SaveAs() escribe el archivo Excel completo en el disco. Para más operaciones con hojas de cálculo, consulta la guía sobre cómo escribir archivos de Excel.

Resultado

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 6 - Salida Básica de Excel

¿Cómo se escriben datos de operaciones SII en celdas de Excel?

IronXL proporciona múltiples enfoques para poblar celdas de Excel, desde asignaciones de celdas individuales hasta operaciones en rangos amplios. Comprender estos métodos te ayuda a elegir el enfoque más eficiente para tu escenario de datos cuando escribes en un archivo de Excel —por ejemplo, al poblar el libro registro de facturas del SII con los campos NIF emisor, NIF receptor, importe base e importe IVA.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("EmployeeData.xlsx");
using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("EmployeeData.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Individual cell assignment
worksheet("A1").Value = "Employee Name"
worksheet("A2").Value = "John Smith"
worksheet("A3").Value = "Jane Doe"
' Range assignment for multiple cells at once
worksheet("B1:B3").Value = "Active"
' Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department") ' C1
worksheet.SetCellValue(1, 2, "Sales") ' C2
worksheet.SetCellValue(2, 2, "Marketing") ' C3
' Array-based header population
Dim headers As String() = {"ID", "Name", "Email", "Phone"}
For i As Integer = 0 To headers.Length - 1
    worksheet.SetCellValue(0, i, headers(i))
Next
' Working with different data types
worksheet("E1").Value = "Salary"
worksheet("E2").Value = 75000.5D ' Decimal for currency
worksheet("E3").Value = 82000.75D
worksheet("F1").Value = "Start Date"
worksheet("F2").Value = New DateTime(2020, 3, 15)
worksheet("F3").Value = New DateTime(2019, 7, 1)
worksheet("G1").Value = "Full Time"
worksheet("G2").Value = True ' Boolean
worksheet("G3").Value = True
workbook.SaveAs("EmployeeData.xlsx")
$vbLabelText   $csharpLabel

El código muestra la flexible dirección de celdas de IronXL. La notación de cadena ("A1") resulta natural para los usuarios de Excel, mientras que los índices numéricos ofrecen control programático para bucles y generación dinámica. Las asignaciones de rango ("B1:B3") establecen de manera eficiente el mismo valor en varias celdas, lo que resulta ideal para inicializar columnas o aplicar valores predeterminados.

IronXL maneja de forma inteligente diferentes tipos de datos. Los decimales mantienen la precisión de los datos financieros (importes en euros para declaraciones AEAT), los objetos DateTime se formatean correctamente como fechas de Excel y los booleanos aparecen como VERDADERO/FALSO. Esta conversión automática elimina el código de formato manual y asegura la integridad de los datos.

Resultado

Cómo Generar Archivo Excel en C# Usando IronXL: Imagen 7 - Salida Excel

¿Cómo se aplica un formato profesional a los ficheros XLSX para el Banco de España y la CNMV?

Los archivos Excel profesionales —incluidos los que se remiten al Banco de España o a la CNMV como parte de las obligaciones de información— requieren más que datos en bruto. La API de estilo de IronXL transforma hojas de cálculo sencillas en documentos empresariales pulidos mediante el formato, los colores y la jerarquía visual. Puede aplicar formato a las celdas para controlar todos los aspectos visuales de su hoja de cálculo.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B width
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");
using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B width
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Header formatting
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"

' Column width adjustment
worksheet.AutoSizeColumn(0) ' Auto-fit column A
worksheet.GetColumn(1).Width = 20 ' Set column B width

' Number formatting
Dim salaryColumn = worksheet("E2:E3")
salaryColumn.FormatString = "$#,##0.00"

' Date formatting
Dim dateColumn = worksheet("F2:F3")
dateColumn.FormatString = "MM/dd/yyyy"

' Cell borders
Dim dataRange = worksheet("A1:G3")
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.TopBorder.Color = "#000000"
dataRange.Style.BottomBorder.Color = "#000000"

' Text alignment
worksheet("A1:G1").Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center

' Alternating row colors for readability (banded rows)
For row As Integer = 2 To 10
    If row Mod 2 = 0 Then
        worksheet($"A{row}:G{row}").Style.SetBackgroundColor("#F2F2F2")
    End If
Next

workbook.SaveAs("FormattedReport.xlsx")
$vbLabelText   $csharpLabel

Este código de formato crea una apariencia profesional que cumple con los estándares empresariales. Encabezados en negrita con colores de fondo establecen una jerarquía visual. El método SetBackgroundColor() acepta códigos de color hexadecimales, lo que permite un control preciso de la combinación de colores. Las propiedades de la fuente incluyen opciones de tamaño, color, negrita, cursiva y subrayado, todas ellas esenciales para crear archivos de Excel que se ajusten a las directrices de imagen corporativa.

Ajustes de ancho de columna previenen la truncación de texto. AutoSizeColumn() ajusta automáticamente el contenido, mientras que GetColumn().Width proporciona un control exacto. El formato de los números utiliza los códigos de formato de Excel; por ejemplo, #.##0,00 € muestra la moneda en euros con separadores de miles y dos decimales conforme al estándar español.

Los bordes definen límites de datos, mejorando la legibilidad. El enum BorderType ofrece varios estilos: fino, medio, grueso, punteado y discontinuo. Los colores de filas alternas, a menudo referidos como "filas con bandas," ayudan a los lectores a seguir la información a través de conjuntos de datos amplios. Para obtener más información sobre la fusión de celdas y otras funciones de diseño, consulta la guía de fusión de celdas.

Resultado

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 8 - Salida Formateada de Excel

¿Cómo se calculan cuotas IVA y totales de declaraciones AEAT con fórmulas Excel?

Las fórmulas de Excel dan vida a las hojas de cálculo con cálculos automáticos. IronXL admite la creación y evaluación de fórmulas, habilitando hojas de cálculo dinámicas para declaraciones del modelo 303. Con fórmulas puede calcular bases imponibles, cuotas devengadas (ventas × tipo IVA) y cuotas soportadas deducibles directamente en el fichero XLSX generado:

using IronXL;
var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data and add row total formulas
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");
using IronXL;
var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data and add row total formulas
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");
Imports IronXL

Dim workbook = WorkBook.Create()
' Create a budget worksheet
Dim budget As WorkSheet = workbook.CreateWorkSheet("Q1 Budget")
' Headers
budget("A1").Value = "Category"
budget("B1").Value = "January"
budget("C1").Value = "February"
budget("D1").Value = "March"
budget("E1").Value = "Q1 Total"
' Budget categories and values
Dim categories As String() = {"Salaries", "Marketing", "Operations", "Equipment", "Training"}
Dim monthlyBudgets As Decimal(,) = {
    {50000, 52000, 51000},
    {15000, 18000, 20000},
    {8000, 8500, 9000},
    {12000, 5000, 7000},
    {3000, 3500, 4000}
}
' Populate data and add row total formulas
For i As Integer = 0 To categories.Length - 1
    budget($"A{i + 2}").Value = categories(i)
    budget($"B{i + 2}").Value = monthlyBudgets(i, 0)
    budget($"C{i + 2}").Value = monthlyBudgets(i, 1)
    budget($"D{i + 2}").Value = monthlyBudgets(i, 2)
    budget($"E{i + 2}").Formula = $"=SUM(B{i + 2}:D{i + 2})"
Next
' Monthly totals row
budget("A7").Value = "Monthly Total"
budget("B7").Formula = "=SUM(B2:B6)"
budget("C7").Formula = "=SUM(C2:C6)"
budget("D7").Formula = "=SUM(D2:D6)"
budget("E7").Formula = "=SUM(E2:E6)"
' Calculate percentages
budget("A9").Value = "Marketing %"
budget("B9").Formula = "=B3/B7*100"
' Average calculation
budget("A10").Value = "Average Spending"
budget("B10").Formula = "=AVERAGE(B2:B6)"
' Evaluate all formulas before saving
workbook.EvaluateAll()
workbook.SaveAs("Budget.xlsx")
$vbLabelText   $csharpLabel

Este ejemplo de presupuesto ilustra la aplicación práctica de fórmulas. La propiedad Formula acepta la sintaxis estándar de las fórmulas de Excel, empezando por el signo igual. IronXL soporta funciones comunes: SUM, AVERAGE, COUNT, MAX, MIN y muchas otras.

El método EvaluateAll() procesa todas las fórmulas, actualizando los valores calculados en todo el libro de trabajo. Esto garantiza que las fórmulas muestren resultados cuando se abre el archivo en Excel. Sin la evaluación, Excel mostraría el texto de la fórmula hasta que el usuario activara el recálculo.

Resultado

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 9 - Salida Excel usando Fórmulas

¿Cómo se exportan datos de bases de datos contables al XLSX del modelo 303?

Las aplicaciones del mundo real a menudo exportan datos de bases de datos a Excel para informes y análisis. En el contexto español, esto incluye la exportación del sistema contable al fichero XLSX de la declaración trimestral del modelo 303, aplicando los principios de minimización de datos de la LOPDGDD antes de generar el fichero final. IronXL hace que este proceso sea sencillo con soporte DataTable incorporado:

using System.Data;
using IronXL;

// Simulate database retrieval (replace with actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}

// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
DataTable salesData = GetSalesData();

// Title row
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;

// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");

// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// Summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");
using System.Data;
using IronXL;

// Simulate database retrieval (replace with actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}

// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
DataTable salesData = GetSalesData();

// Title row
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;

// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");

// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// Summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");
Imports System.Data
Imports IronXL

' Simulate database retrieval (replace with actual database code)
Function GetSalesData() As DataTable
    Dim dt As New DataTable("Sales")
    dt.Columns.Add("OrderID", GetType(Integer))
    dt.Columns.Add("CustomerName", GetType(String))
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Quantity", GetType(Integer))
    dt.Columns.Add("UnitPrice", GetType(Decimal))
    dt.Columns.Add("OrderDate", GetType(DateTime))
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99D, DateTime.Now.AddDays(-5))
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99D, DateTime.Now.AddDays(-4))
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99D, DateTime.Now.AddDays(-3))
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99D, DateTime.Now.AddDays(-2))
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99D, DateTime.Now.AddDays(-1))
    Return dt
End Function

' Export to Excel
Dim reportWorkbook As WorkBook = WorkBook.Create()
Dim reportSheet As WorkSheet = reportWorkbook.CreateWorkSheet("Sales Report")
Dim salesData As DataTable = GetSalesData()

' Title row
reportSheet("A1").Value = "Order Report - " & DateTime.Now.ToString("MMMM yyyy")
reportSheet.Merge("A1:F1")
reportSheet("A1").Style.Font.Bold = True
reportSheet("A1").Style.Font.Height = 14

' Headers
Dim headerRow As Integer = 3
For col As Integer = 0 To salesData.Columns.Count - 1
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns(col).ColumnName)
Next
Dim headers = reportSheet($"A{headerRow}:F{headerRow}")
headers.Style.Font.Bold = True
headers.Style.SetBackgroundColor("#D9E1F2")

' Data rows
For row As Integer = 0 To salesData.Rows.Count - 1
    For col As Integer = 0 To salesData.Columns.Count - 1
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows(row)(col))
    Next
    reportSheet($"G{row + headerRow + 1}").Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}"
Next

' Total header
reportSheet("G3").Value = "Total"
reportSheet("G3").Style.Font.Bold = True
reportSheet("G3").Style.SetBackgroundColor("#D9E1F2")

' Format currency and date columns
reportSheet($"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
reportSheet($"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
reportSheet($"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}").FormatString = "MM/dd/yyyy"

' Summary section
Dim summaryRow As Integer = headerRow + salesData.Rows.Count + 2
reportSheet($"A{summaryRow}").Value = "Summary"
reportSheet($"A{summaryRow}").Style.Font.Bold = True
reportSheet($"A{summaryRow + 1}").Value = "Total Orders:"
reportSheet($"B{summaryRow + 1}").Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})"
reportSheet($"A{summaryRow + 2}").Value = "Total Revenue:"
reportSheet($"B{summaryRow + 2}").Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})"
reportSheet($"B{summaryRow + 2}").FormatString = "$#,##0.00"

For col As Integer = 0 To 6
    reportSheet.AutoSizeColumn(col)
Next
reportWorkbook.EvaluateAll()
reportWorkbook.SaveAs("DatabaseExport.xlsx")
$vbLabelText   $csharpLabel

Este ejemplo muestra un flujo de trabajo completo de la base de datos a Excel. El DataTable simula la recuperación de una base de datos; en producción, sustitúyalo por consultas reales a bases de datos utilizando Entity Framework, Dapper o ADO.NET. El enfoque de asignación manual ofrece control completo sobre el formateo y diseño.

El código crea un informe profesional con un título, encabezados formateados, y filas de datos. Las columnas de fórmula calculan totales de línea dinámicamente. La sección de resumen utiliza fórmulas de Excel para contar los pedidos y sumar los ingresos, lo que garantiza que estos valores se actualicen si los datos cambian.

Resultado

Cómo Generar Archivo Excel en C# Usando IronXL: Imagen 10 - Exportación de Base de Datos a Excel

¿Necesita poner en producción los informes de Excel? Consigue una licencia para aprovechar todo el potencial de IronXL en implementaciones de producción.

¿Cómo se gestionan varias hojas para SII, modelo 303 y modelo 390 en un único XLSX?

Los archivos Excel complejos de compliance fiscal a menudo requieren múltiples hojas de trabajo para organizar datos relacionados. Un único libro XLSX puede contener el libro registro de facturas del SII, el resumen del modelo 303 y el modelo 390 de resumen anual de IVA en pestañas separadas. IronXL simplifica esta gestión con métodos intuitivos. Puedes abrir y gestionar hojas de libros de trabajo con solo unas pocas líneas de código.

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}

// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");
using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}

// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");
Imports IronXL

Dim companyReport As WorkBook = WorkBook.Create()
' Create department sheets
Dim salesSheet As WorkSheet = companyReport.CreateWorkSheet("Sales")
Dim inventorySheet As WorkSheet = companyReport.CreateWorkSheet("Inventory")
Dim summarySheet As WorkSheet = companyReport.CreateWorkSheet("Summary")

' Populate Sales sheet
salesSheet("A1").Value = "Sales Dashboard"
salesSheet("A3").Value = "Region"
salesSheet("B3").Value = "Q1 Sales"
salesSheet("C3").Value = "Q2 Sales"
Dim regions As String() = {"North", "South", "East", "West"}
Dim q1Sales As Decimal() = {250000, 180000, 220000, 195000}
Dim q2Sales As Decimal() = {275000, 195000, 240000, 210000}
For i As Integer = 0 To regions.Length - 1
    salesSheet($"A{i + 4}").Value = regions(i)
    salesSheet($"B{i + 4}").Value = q1Sales(i)
    salesSheet($"C{i + 4}").Value = q2Sales(i)
Next

' Populate Inventory sheet
inventorySheet("A1").Value = "Inventory Status"
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim stock As Integer() = {150, 45, 200}
Dim reorderPoint As Integer() = {100, 50, 75}
For i As Integer = 0 To products.Length - 1
    inventorySheet($"A{i + 4}").Value = products(i)
    inventorySheet($"B{i + 4}").Value = stock(i)
    inventorySheet($"C{i + 4}").Value = reorderPoint(i)
    Dim status As String = If(stock(i) <= reorderPoint(i), "REORDER", "OK")
    inventorySheet($"D{i + 4}").Value = status
    If status = "REORDER" Then
        inventorySheet($"D{i + 4}").Style.Font.Color = "#FF0000"
    End If
Next

' Summary sheet with cross-sheet formulas
summarySheet("A1").Value = "Company Overview"
summarySheet("A4").Value = "Total Q1 Sales"
summarySheet("B4").Formula = "=SUM(Sales!B4:B7)"
summarySheet("A5").Value = "Total Q2 Sales"
summarySheet("B5").Formula = "=SUM(Sales!C4:C7)"
summarySheet("A6").Value = "Products Need Reorder"
summarySheet("B6").Formula = "=COUNTIF(Inventory!D4:D6,""REORDER"")"

' Apply consistent formatting across all sheets
For Each sheet As WorkSheet In companyReport.WorkSheets
    sheet("A1").Style.Font.Bold = True
    sheet("A1").Style.Font.Height = 14
Next

companyReport.SaveAs("CompanyReport.xlsx")
$vbLabelText   $csharpLabel

Este ejemplo crea un informe completo de múltiples hojas. Cada hoja de cálculo tiene una finalidad específica: datos de ventas, seguimiento de inventario y vista resumida. La hoja de resumen consolida métricas clave usando fórmulas entre hojas. Fíjate en la sintaxis de referencia de la hoja: "Sales!B4:B7" hace referencia a las celdas B4 a B7 de la hoja Sales.

La hoja de inventario demuestra lógica condicional, coloreando elementos con bajo stock en rojo para una atención inmediata. El bucle foreach aplica un formato coherente en todas las hojas, manteniendo un aspecto profesional en todo el libro de trabajo.

¿Cuáles son las mejores prácticas para generar Excel SII/AEAT en C# con IronXL?

Una generación eficiente de ficheros XLSX para compliance fiscal en C# requiere enfoques reflexivos para el uso de memoria, manejo de errores, implementación y cumplimiento de la LOPDGDD.

La gestión de memoria se vuelve crítica con archivos grandes —como el libro registro del SII con miles de facturas. Procese los datos por lotes en lugar de cargar conjuntos de datos completos de una sola vez. El siguiente patrón mantiene predecible el uso de memoria para exportaciones de gran volumen:

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable batches
foreach (var batch in GetDataInBatches(rowsPerBatch))
{
    foreach (var record in batch)
    {
        sheet[$"A{currentRow}"].Value = record.Id;
        sheet[$"B{currentRow}"].Value = record.Name;
        sheet[$"C{currentRow}"].Value = record.Value;
        currentRow++;
    }
}
workbook.SaveAs("LargeDataset.xlsx");
using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable batches
foreach (var batch in GetDataInBatches(rowsPerBatch))
{
    foreach (var record in batch)
    {
        sheet[$"A{currentRow}"].Value = record.Id;
        sheet[$"B{currentRow}"].Value = record.Name;
        sheet[$"C{currentRow}"].Value = record.Value;
        currentRow++;
    }
}
workbook.SaveAs("LargeDataset.xlsx");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
Dim rowsPerBatch As Integer = 1000
Dim currentRow As Integer = 2
sheet("A1").Value = "ID"
sheet("B1").Value = "Name"
sheet("C1").Value = "Value"
' Process records in manageable batches
For Each batch In GetDataInBatches(rowsPerBatch)
    For Each record In batch
        sheet($"A{currentRow}").Value = record.Id
        sheet($"B{currentRow}").Value = record.Name
        sheet($"C{currentRow}").Value = record.Value
        currentRow += 1
    Next
Next
workbook.SaveAs("LargeDataset.xlsx")
$vbLabelText   $csharpLabel

En el caso de las aplicaciones web, genere archivos Excel en memoria y transmítalos directamente a los usuarios en lugar de escribir archivos temporales en el disco. Incluya siempre la lógica de generación en el manejo de errores para evitar fallos y proporcionar información útil:

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}
// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}
Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Function DownloadExcel() As IActionResult
        Try
            Dim workbook As WorkBook = WorkBook.Create()
            Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
            sheet("A1").Value = "Report Data"
            ' Populate report data here...
            Dim stream As New MemoryStream()
            workbook.SaveAs(stream)
            stream.Position = 0
            Return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx")
        Catch ex As Exception
            Console.WriteLine($"Excel generation failed: {ex.Message}")
            Return StatusCode(500, "Failed to generate Excel file.")
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

La siguiente tabla resume las principales prácticas recomendadas y cuándo aplicarlas en proyectos de compliance fiscal:

Prácticas recomendadas de IronXL para la generación de Excel SII/AEAT en C#
Guión Enfoque recomendado Ventaja
Large datasets (>10,000 rows) — libro registro SII Procesamiento por lotes con escrituras por fragmentos Menor consumo de memoria
Descargas de aplicaciones web — portal AEAT MemoryStream en lugar de archivos temporales Sin E/S de disco, respuesta más rápida
Implementación en producción Linux/Docker Incluir una clave de licencia válida de IronXL Sin marca de agua en los archivos generados
Moneda (euros) y fechas fiscales Utilizar la propiedad FormatString con formato español Visualización correcta de la configuración regional en Excel
Informes dinámicos con fórmulas de IVA Llama a EvaluateAll() antes de SaveAs() Las fórmulas muestran valores calculados
Compliance LOPDGDD Filtrar columnas de datos personales antes de generar XLSX Minimización de datos personales en exportaciones a AEAT

IronXL funciona en entornos restringidos sin permisos elevados, haciéndolo adecuado para hosting compartido e implementaciones contenedorizadas. Incluya el archivo de licencia de IronXL en su paquete de implementación y asegúrese de que su aplicación tenga permisos de escritura para cualquier operación con archivos temporales que sea necesaria. Para obtener orientación adicional sobre la implementación, consulte la descripción general de las características de IronXL y la documentación completa de la API.

¿Qué pasos se pueden dar a partir de aquí?

IronXL es la librería Excel C# SII AEAT de referencia para los desarrolladores de compliance fiscal en España: IronXL genera ficheros SII, modelos 303/347/390, remisiones al Banco de España/CNMV, y datos VeriFactu/TicketBAI directamente en XLSX desde servidores Linux o Docker sin ninguna dependencia de Office. Has aprendido a crear libros, rellenar celdas, aplicar formato, utilizar fórmulas, exportar datos de bases de datos contables y gestionar varias hojas de cálculo en un único fichero de compliance.

Para profundizar, explore las guías prácticas de IronXL.Excel para leer y modificar archivos Excel existentes, o la página de Licencia Trial para empezar a trabajar en producción. Consulte las opciones de licencia que se ajustan a los requisitos y la escala de su proyecto.

Cómo Generar un Archivo Excel en C# Usando IronXL: Imagen 11 - Licencia

Preguntas Frecuentes

¿Cómo puedo generar el fichero XLSX para el SII de la AEAT en C# con IronXL en Linux?

Con IronXL puede generar ficheros XLSX para el SII (Suministro Inmediato de Información) de la AEAT directamente en C# sin requerir Microsoft Office. IronXL funciona en servidores Linux, Docker y Azure, que son los entornos habituales de los servicios de integración con el SII. Use WorkBook.Create(ExcelFileFormat.XLSX) y rellene el DataTable con los registros de facturas.

¿Se requiere Microsoft Office para generar ficheros XLSX para la AEAT con IronXL?

No, IronXL no requiere Microsoft Office. Genera ficheros XLSX para el SII, modelos 303/347/390, VeriFactu y TicketBAI en C# sin ninguna dependencia de Office, lo que es esencial para servidores Linux y pipelines de compliance fiscal.

¿Cuáles son las ventajas de usar IronXL sobre los métodos tradicionales para compliance fiscal AEAT?

IronXL elimina la necesidad de Microsoft Office y la interoperabilidad COM compleja, ofrece compatibilidad con Linux/Docker/Azure, soporte para múltiples hojas (SII + modelos 303/347/390 en un único XLSX) y una API sencilla para generar ficheros fiscales programáticamente en C#.

¿Puedo integrar bases de datos contables con la generación de XLSX para AEAT usando IronXL?

Sí, IronXL admite la integración con DataTable, lo que permite exportar datos del sistema contable (IVA, SII, operaciones con terceros) a ficheros XLSX para declaraciones AEAT de manera eficiente.

¿Qué formatos de archivos se pueden generar con IronXL para compliance fiscal?

IronXL permite crear archivos XLS, XLSX, CSV, JSON y XML, lo que lo hace versátil para diferentes necesidades de generación de ficheros fiscales, desde el SII hasta el modelo 390.

¿IronXL admite formato avanzado en euros y fechas para ficheros fiscales AEAT?

Sí, IronXL admite funciones de formato avanzadas mediante FormatString, permitiendo formatos de moneda en euros y fechas en formato español para los ficheros XLSX de compliance fiscal.

¿Es posible automatizar la generación de hojas SII/AEAT con IronXL?

Sí, IronXL permite automatizar la generación de hojas del libro registro del SII, resúmenes del modelo 303, datos del modelo 347 y remisiones al Banco de España, todo ello en pipelines automatizados de compliance fiscal.

¿Cómo se cumple la LOPDGDD al generar XLSX para la AEAT con IronXL?

Antes de llamar a SaveAs en IronXL, filtre las columnas del DataTable para eliminar datos personales que no sean estrictamente necesarios para la declaración fiscal, aplicando el principio de minimización de datos de la LOPDGDD.

¿Cómo puedo crear un XLSX multi-hoja con SII, modelo 303 y modelo 390 en IronXL?

Con IronXL puede crear un WorkBook con múltiples WorkSheet: una para el libro registro del SII, otra para el resumen del modelo 303 y otra para el modelo 390. Cada hoja se convierte en una pestaña del libro XLSX exportado.

¿Dónde puedo encontrar documentación para usar IronXL en aplicaciones de compliance fiscal .NET?

Puede encontrar documentación completa sobre el uso de IronXL en C# en el sitio web de Iron Software, que incluye tutoriales y ejemplos para generación de XLSX, lectura de ficheros Excel y exportación de datos fiscales.

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