C# Guardar en CSV usando IronXL

Introducción a los valores separados por comas

Un archivo de valores separados por comas (CSV) es uno de los formatos más utilizados para almacenar e intercambiar datos tabulares entre distintas aplicaciones. En su forma más simple, un archivo CSV es un archivo de texto sin formato en el que cada línea contiene una serie de valores separados por comas. Esta estructura sencilla hace que los datos CSV sean fáciles de generar, leer y procesar en una amplia gama de sistemas de software. El formato CSV es ligero y legible, por lo que es una opción popular para exportar informes, transferir datos entre bases de datos e integrarlos con herramientas de análisis.

Comprensión del formato CSV

El formato CSV está diseñado para ser sencillo: cada línea de un archivo CSV representa un único registro, y cada valor dentro de esa línea está separado por una coma. La primera línea del archivo suele servir de encabezado, con los nombres de cada columna. Cada línea siguiente contiene los datos reales, y cada valor corresponde a una columna de la cabecera. Esta estructura permite que los archivos CSV representen tablas complejas de datos en un formato fácil de leer y de analizar.

¿Cómo instalo IronXL en mi proyecto?

Añadir IronXL a un nuevo proyecto sólo lleva unos segundos a través de los paquetes NuGet, el gestor de paquetes de Microsoft para .NET. Abra Visual Studio, acceda a la consola del gestor de paquetes NuGet y ejecute el siguiente comando:

Install-Package IronXL.Excel

C# Guardar en CSV usando IronXL: Imagen 1 - Instalación

Como alternativa, haga clic con el botón derecho en su proyecto en el Explorador de soluciones, seleccione "Administrar paquetes NuGet", busque "IronXL" en la pestaña Examinar y haga clic en Instalar. IronXL es compatible con .NET Framework 4.6.2+, .NET Core, .NET 5/6/7/8, y se ejecuta en cualquier plataforma sin dependencias externas ni requisitos de interoperabilidad COM.

Una vez instalado, añada el espacio de nombres IronXL a su archivo de código mediante la sentencia using:

using IronXL;

using IronXL;

Este espacio de nombres único proporciona acceso a todas las clases necesarias para la creación de hojas de cálculo y las operaciones de exportación a CSV. A diferencia de los enfoques que se basan en la clase StreamWriter o StringBuilder para escribir archivos CSV manualmente, IronXL maneja toda la complejidad del formato CSV adecuado de forma automática.

¿Cómo crear un nuevo archivo CSV desde cero?

Crear un nuevo archivo CSV mediante programación implica tres pasos sencillos: crear un libro de trabajo, rellenarlo con datos y guardarlo en formato CSV. La intuitiva API de IronXL refleja el conocido modelo de objetos de Excel, lo que facilita a los desarrolladores la escritura de código que funciona con conceptos de hojas de cálculo en una aplicación de consola o en cualquier tipo de proyecto .NET.

Considere un escenario en el que necesita exportar una lista de objetos de empleados a CSV. He aquí un ejemplo completo que muestra cómo escribir datos CSV:

using IronXL;
class Program
{
 public static void Main(string[] args)
 {
  // Create a new workbook and worksheet
  WorkBook workBook = WorkBook.Create();
  WorkSheet sheet = workBook.CreateWorkSheet("Employees");
  // Add header row with column names
  sheet["A1"].Value = "EmployeeID";
  sheet["B1"].Value = "Name";
  sheet["C1"].Value = "Department";
  sheet["D1"].Value = "Salary";
  // Add employee data rows
  sheet["A2"].Value = 1001;
  sheet["B2"].Value = "Sarah Johnson";
  sheet["C2"].Value = "Engineering";
  sheet["D2"].Value = 85000;
  sheet["A3"].Value = 1002;
  sheet["B3"].Value = "Michael Chen";
  sheet["C3"].Value = "Marketing";
  sheet["D3"].Value = 72000;
  sheet["A4"].Value = 1003;
  sheet["B4"].Value = "Emily Rodriguez";
  sheet["C4"].Value = "Finance";
  sheet["D4"].Value = 91000;
  // Save as CSV file - output goes to the specified path
  workBook.SaveAsCsv("employees.csv", ",");
 }
}

using IronXL;
class Program
{
 public static void Main(string[] args)
 {
  // Create a new workbook and worksheet
  WorkBook workBook = WorkBook.Create();
  WorkSheet sheet = workBook.CreateWorkSheet("Employees");
  // Add header row with column names
  sheet["A1"].Value = "EmployeeID";
  sheet["B1"].Value = "Name";
  sheet["C1"].Value = "Department";
  sheet["D1"].Value = "Salary";
  // Add employee data rows
  sheet["A2"].Value = 1001;
  sheet["B2"].Value = "Sarah Johnson";
  sheet["C2"].Value = "Engineering";
  sheet["D2"].Value = 85000;
  sheet["A3"].Value = 1002;
  sheet["B3"].Value = "Michael Chen";
  sheet["C3"].Value = "Marketing";
  sheet["D3"].Value = 72000;
  sheet["A4"].Value = 1003;
  sheet["B4"].Value = "Emily Rodriguez";
  sheet["C4"].Value = "Finance";
  sheet["D4"].Value = 91000;
  // Save as CSV file - output goes to the specified path
  workBook.SaveAsCsv("employees.csv", ",");
 }
}

El método WorkBook.Create() inicializa una nueva hoja de cálculo completamente en memoria, sin requerir archivos temporales ni E/S de disco hasta la operación de guardado final. El método CreateWorkSheet() añade una hoja de trabajo con nombre al libro de trabajo; este nombre es importante cuando se exportan libros de trabajo con varias hojas a CSV.

using IronXL;
// Define the Student class with public string properties
public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
}
// In your program class or method
var students = new List<Student>
{
    new Student { FirstName = "John", LastName = "Smith", Email = "john@example.com" },
    new Student { FirstName = "Jane", LastName = "Doe", Email = "jane@example.com" }
};
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.DefaultWorkSheet;
// Add header row
sheet["A1"].Value = "FirstName";
sheet["B1"].Value = "LastName";
sheet["C1"].Value = "Email";
// Use foreach to iterate through the list and write each item
int row = 2;
foreach (var item in students)
{
    sheet[$"A{row}"].Value = item.FirstName;
    sheet[$"B{row}"].Value = item.LastName;
    sheet[$"C{row}"].Value = item.Email;
    row++;
}
workBook.SaveAsCsv("students.csv", ",");

using IronXL;
// Define the Student class with public string properties
public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
}
// In your program class or method
var students = new List<Student>
{
    new Student { FirstName = "John", LastName = "Smith", Email = "john@example.com" },
    new Student { FirstName = "Jane", LastName = "Doe", Email = "jane@example.com" }
};
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.DefaultWorkSheet;
// Add header row
sheet["A1"].Value = "FirstName";
sheet["B1"].Value = "LastName";
sheet["C1"].Value = "Email";
// Use foreach to iterate through the list and write each item
int row = 2;
foreach (var item in students)
{
    sheet[$"A{row}"].Value = item.FirstName;
    sheet[$"B{row}"].Value = item.LastName;
    sheet[$"C{row}"].Value = item.Email;
    row++;
}
workBook.SaveAsCsv("students.csv", ",");

¿Cómo convierto un archivo Excel existente en CSV?

La conversión de hojas de cálculo de Excel a formato CSV es un requisito común cuando se integran con sistemas heredados, se preparan datos para importaciones de bases de datos o se generan resultados legibles por máquina a partir de informes creados por humanos. IronXL se encarga de esta conversión con un código mínimo y preservando la precisión de los datos. El archivo existe en disco y puede cargarse directamente.

using IronXL;

// Load an existing Excel file from the specified location
WorkBook workBook = WorkBook.Load("Monthly_Report_20251012.xlsx");

// Convert and save as CSV format
workBook.SaveAsCsv("Monthly_Report_20251012.csv");

using IronXL;

// Load an existing Excel file from the specified location
WorkBook workBook = WorkBook.Load("Monthly_Report_20251012.xlsx");

// Convert and save as CSV format
workBook.SaveAsCsv("Monthly_Report_20251012.csv");

El método Load() abre archivos de Excel en varios formatos, incluidos XLSX, XLS, XLSM e incluso archivos CSV o TSV existentes. Gracias a esta flexibilidad, los desarrolladores pueden crear cadenas de exportación estandarizadas que acepten archivos de entrada independientemente de su formato original. El sistema gestiona internamente las operaciones de archivo.

using IronXL;

// Load a multi-sheet workbook (e.g., annual sales by region)
WorkBook workBook = WorkBook.Load("annual_sales.xlsx");

// Export all sheets to CSV - creates separate files for each
workBook.SaveAsCsv("sales_export.csv");
// Output: sales_export.North.csv, sales_export.South.csv, sales_export.East.csv, etc.

// Or export a specific worksheet
WorkSheet northRegion = workBook.GetWorkSheet("North");
northRegion.SaveAsCsv("north_region_sales.csv");

using IronXL;

// Load a multi-sheet workbook (e.g., annual sales by region)
WorkBook workBook = WorkBook.Load("annual_sales.xlsx");

// Export all sheets to CSV - creates separate files for each
workBook.SaveAsCsv("sales_export.csv");
// Output: sales_export.North.csv, sales_export.South.csv, sales_export.East.csv, etc.

// Or export a specific worksheet
WorkSheet northRegion = workBook.GetWorkSheet("North");
northRegion.SaveAsCsv("north_region_sales.csv");

¿Cómo exportar una tabla de datos a CSV?

Las aplicaciones empresariales suelen trabajar con objetos DataTable rellenados a partir de consultas a bases de datos, respuestas a API o procesamiento de datos en memoria. IronXL tiende un puente entre estas estructuras de datos .NET y las exportaciones de archivos, proporcionando una ruta fiable desde la memoria de la aplicación hasta los archivos CSV compartibles. Este método es más robusto que escribir manualmente archivos CSV con un enfoque de escritor var o utilizar un nuevo StreamWriter.

using IronXL;
using System.Data;

// Create and populate a DataTable with columns
DataTable products = new DataTable();
products.Columns.Add("SKU", typeof(string));
products.Columns.Add("ProductName", typeof(string));
products.Columns.Add("Price", typeof(decimal));
products.Columns.Add("InStock", typeof(int));

// Add rows of data
products.Rows.Add("SKU-001", "Wireless Mouse", 29.99m, 150);
products.Rows.Add("SKU-002", "Mechanical Keyboard", 89.99m, 75);
products.Rows.Add("SKU-003", "USB-C Hub", 45.99m, 200);

// Create workbook and transfer DataTable contents
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.DefaultWorkSheet;

// Add header row from column names
for (int col = 0; col < products.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, products.Columns[col].ColumnName);
}

// Add data rows using a loop
for (int row = 0; row < products.Rows.Count; row++)
{
    for (int col = 0; col < products.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, products.Rows[row][col].ToString());
    }
}

// Export to CSV and save to the specified path
workBook.SaveAsCsv("product_inventory.csv", ",");

using IronXL;
using System.Data;

// Create and populate a DataTable with columns
DataTable products = new DataTable();
products.Columns.Add("SKU", typeof(string));
products.Columns.Add("ProductName", typeof(string));
products.Columns.Add("Price", typeof(decimal));
products.Columns.Add("InStock", typeof(int));

// Add rows of data
products.Rows.Add("SKU-001", "Wireless Mouse", 29.99m, 150);
products.Rows.Add("SKU-002", "Mechanical Keyboard", 89.99m, 75);
products.Rows.Add("SKU-003", "USB-C Hub", 45.99m, 200);

// Create workbook and transfer DataTable contents
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.DefaultWorkSheet;

// Add header row from column names
for (int col = 0; col < products.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, products.Columns[col].ColumnName);
}

// Add data rows using a loop
for (int row = 0; row < products.Rows.Count; row++)
{
    for (int col = 0; col < products.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, products.Rows[row][col].ToString());
    }
}

// Export to CSV and save to the specified path
workBook.SaveAsCsv("product_inventory.csv", ",");

Este patrón itera a través de la estructura DataTable, transfiriendo primero las cabeceras de las columnas y rellenando después cada fila de datos de forma sistemática. La propiedad DefaultWorkSheet proporciona un acceso rápido a la primera hoja de trabajo de un libro recién creado, eliminando la necesidad de crear hojas de trabajo explícitas en situaciones sencillas. Por defecto, el método procesa todas las filas en secuencia.

¿Cómo manejo los delimitadores personalizados en archivos CSV?

Los distintos sistemas y normas regionales requieren distintos caracteres delimitadores. Aunque la coma es el separador estándar en muchos países, a menudo se prefiere el punto y coma en las regiones europeas, donde la coma sirve como separador decimal en los valores numéricos. Los archivos separados por tabulaciones (TSV) son populares cuando los datos de origen contienen comas en los valores de los campos. El método SaveAsCsv() de IronXL se adapta a todos estos escenarios sin requerir código adicional para manejar cada línea de salida.

using IronXL;
WorkBook workBook = WorkBook.Load("data.xlsx");
// Standard comma delimiter (default format)
workBook.SaveAsCsv("output_comma.csv", ",");
// Semicolon delimiter (common in European systems)
workBook.SaveAsCsv("output_semicolon.csv", ";");
// Tab delimiter (TSV format)
workBook.SaveAsCsv("output_tab.tsv", "\t");
// Pipe delimiter (used in some data interchange formats)
workBook.SaveAsCsv("output_pipe.csv", "|");

using IronXL;
WorkBook workBook = WorkBook.Load("data.xlsx");
// Standard comma delimiter (default format)
workBook.SaveAsCsv("output_comma.csv", ",");
// Semicolon delimiter (common in European systems)
workBook.SaveAsCsv("output_semicolon.csv", ";");
// Tab delimiter (TSV format)
workBook.SaveAsCsv("output_tab.tsv", "\t");
// Pipe delimiter (used in some data interchange formats)
workBook.SaveAsCsv("output_pipe.csv", "|");

El segundo parámetro de SaveAsCsv() acepta cualquier cadena como delimitador, lo que proporciona una flexibilidad total para la integración con diversos sistemas y requisitos regionales. Cuando genere archivos para su distribución internacional, tenga en cuenta las expectativas de la configuración regional del sistema de destino: los sistemas financieros europeos suelen esperar la separación por punto y coma, mientras que los sistemas norteamericanos suelen usar comas por defecto.

Mejores prácticas

Cuando se trabaja con archivos CSV en C#, seguir las mejores prácticas garantiza que los datos sean precisos, legibles y compatibles con otros sistemas. He aquí algunas directrices esenciales:

• Delimitadores coherentes: Utilice siempre un delimitador coherente, como una coma o un punto y coma, en todo el archivo CSV. Esto ayuda a evitar errores de análisis al importar o exportar datos.
• Citar valores especiales: Si sus valores de datos contienen comas, comillas u otros caracteres especiales, enciérrelos entre comillas dobles para mantener la integridad de sus datos CSV.
• Formatos de fecha y hora: Utilice un formato de fecha y hora coherente en todos sus archivos CSV para evitar confusiones y garantizar la compatibilidad con otras aplicaciones.
• Evite las nuevas líneas en los valores: Absténgase de incluir caracteres de nueva línea en los valores, ya que pueden alterar la estructura de las filas y causar problemas de formato.
• Aprovecha las bibliotecas: Utilice bibliotecas como CsvHelper para simplificar la lectura y escritura de archivos CSV. CsvHelper gestiona muchas de las complejidades del formato CSV, como el escape, las comillas y los delimitadores personalizados.
• Manejo de archivos: Compruebe siempre si el archivo existe antes de escribir y gestione las excepciones con elegancia. Utilice la sentencia using para asegurarse de que los flujos de archivos se cierran y eliminan correctamente después de su uso.

Por ejemplo, puede iniciar un nuevo proyecto en Visual Studio, instalar el paquete NuGet CsvHelper y utilizar la clase CsvWriter para escribir datos en un archivo CSV. Defina una clase Student con propiedades como Firstname y Lastname y, a continuación, exporte una lista de objetos Student a un archivo CSV mediante CsvWriter. Este enfoque no solo agiliza el flujo de trabajo, sino que también reduce el riesgo de errores, garantizando que los archivos CSV estén bien estructurados y listos para su uso en cualquier aplicación.

Conclusión

La creación y exportación de archivos CSV en C# se vuelve notablemente eficiente con IronXL. Desde la generación de nuevos archivos con datos estructurados hasta la conversión de complejos libros de Excel de varias hojas, la biblioteca ofrece una API limpia e intuitiva que gestiona la complejidad subyacente del formato CSV adecuado, el escape de caracteres especiales y la evaluación de fórmulas. A diferencia de los enfoques manuales que requieren la escritura de código personalizado con variables var stream y var csv o la lógica de añadir texto, IronXL agiliza todo el proceso.

Los métodos y técnicas clave que se cubren en este post incluyen:

• WorkBook.Create() para inicializar nuevas hojas de cálculo en memoria
• WorkBook.Load() para abrir archivos Excel existentes en cualquier formato compatible
• SaveAsCsv() para exportar datos con delimitadores personalizables
• Exportación de hojas de trabajo individuales mediante GetWorkSheet() para conversiones específicas
• Patrones de iteración de DataTable para flujos de trabajo de base de datos a CSV
• Exportación de listas de objetos mediante bucles foreach

Inicie su prueba gratuita para explorar la gama completa de capacidades de la hoja de cálculo, o compre una licencia para la implementación en producción. Para obtener ejemplos adicionales que cubran escenarios avanzados como el estilo de celdas, la creación de fórmulas y la generación de gráficos, explore la completa documentación de IronXL y ejemplos de código de la biblioteca.