Convertir C# DataTable a CSV: 3 métodos fáciles con ejemplos

Exportar DataTable a CSV en C# es un requisito común para los desarrolladores que necesitan guardar, compartir o analizar datos tabulares de manera eficiente. El objeto DataTable en .NET proporciona una forma estructurada de almacenar filas y columnas en la memoria, pero a menudo necesitas convertir estos datos en un archivo CSV para Excel, herramientas de informes u otros sistemas.

Este tutorial explica tres métodos sencillos para exportar DataTable a CSV en C#, con instrucciones paso a paso y ejemplos de código prácticos. Ya sea que estés trabajando con conjuntos de datos pequeños o tablas grandes a nivel de producción, estos enfoques te ayudarán a realizar la conversión de DataTable a CSV en C# de forma rápida y fiable.

Tabla de Contenidos

• Por qué exportar DataTable a CSV en C#
• Método 1: Conversión manual de C# DataTable a CSV usando StringBuilder
• Método 2: Exportación de C# DataTable grande a CSV usando StreamWriter
• Método 3: Usar Spire.XLS for .NET para convertir DataTable a CSV en C#
• Comparación de rendimiento de los métodos de DataTable a CSV
• ¿Qué método deberías usar?
• Manejo de casos especiales y mejores prácticas para DataTable a CSV
• Conclusión
• Preguntas frecuentes

Por qué exportar DataTable a CSV en C#

Exportar un DataTable a CSV en C# ofrece varias ventajas clave:

• Formato de datos universal – CSV es compatible con Excel, Google Sheets, bases de datos y muchas aplicaciones.
• Legible y simple – A diferencia de JSON o XML, CSV es legible por humanos y fácil de editar manualmente.
• Integración perfecta – Muchas aplicaciones empresariales, CRMs y herramientas de informes aceptan archivos CSV.
• Rendimiento rápido – La generación de CSV es ligera y eficiente.
• Compatibilidad multiplataforma – Los archivos CSV se pueden abrir y procesar en cualquier sistema.

Método 1: Conversión manual de C# DataTable a CSV usando StringBuilder

Exportar manualmente un DataTable a CSV en C# usando StringBuilder te da control total sobre las reglas de formato y escape, lo que lo hace ideal para conjuntos de datos de tamaño pequeño a mediano.

Pasos para convertir DataTable a CSV en C# usando StringBuilder

• Crea u obtén un DataTable de tu fuente (base de datos, API o manualmente).
• Inicializa un StringBuilder para almacenar el contenido CSV.
• Añade los encabezados de las columnas recorriendo DataTable.Columns.
• Recorre las filas de DataTable y añade el valor de cada celda.
• Escapa caracteres especiales como comas, comillas o saltos de línea.
• Escribe la cadena final en un archivo CSV usando File.WriteAllText.

Ejemplo de código

using System;
using System.Data;
using System.IO;
using System.Text;

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Paso 1: Crear un DataTable
            // -------------------------------
            DataTable table = new DataTable("Employees");

            // Definir columnas: ID, Name, Department, Salary, JoinDate, Email
            table.Columns.Add("ID", typeof(int));
            table.Columns.Add("Name", typeof(string));
            table.Columns.Add("Department", typeof(string));
            table.Columns.Add("Salary", typeof(decimal));
            table.Columns.Add("JoinDate", typeof(DateTime));
            table.Columns.Add("Email", typeof(string));

            // Añadir filas de muestra con datos más ricos
            table.Rows.Add(1, "Alice Johnson", "HR", 60000, new DateTime(2019, 3, 15), "alice.johnson@example.com");
            table.Rows.Add(2, "Bob Smith", "IT", 75000, new DateTime(2018, 7, 22), "bob.smith@example.com");
            table.Rows.Add(3, "Charlie Brown", "Finance", 82000, new DateTime(2020, 1, 10), "charlie.brown@example.com");
            table.Rows.Add(4, "Diana Prince", "Marketing", 67000, new DateTime(2021, 5, 5), "diana.prince@example.com");
            table.Rows.Add(5, "Ethan Hunt", "Operations", 90000, new DateTime(2017, 9, 30), "ethan.hunt@example.com");
            table.Rows.Add(6, "Fiona Gallagher", "IT", 72000, new DateTime(2019, 11, 12), "fiona.gallagher@example.com");

            // -------------------------------
            // Paso 2: Exportar DataTable a CSV
            // -------------------------------
            string csvPath = "employees.csv";
            DataTableToCsv(table, csvPath);

            Console.WriteLine($"Archivo CSV creado exitosamente: {csvPath}");
        }

        /// <summary>
        /// Convierte un DataTable a un archivo CSV.
        /// </summary>
        /// <param name="dt">El DataTable a exportar</param>
        /// <param name="filePath">La ruta donde se guardará el archivo CSV</param>
        public static void DataTableToCsv(DataTable dt, string filePath)
        {
            // Usar StringBuilder para construir eficientemente el contenido CSV
            StringBuilder sb = new StringBuilder();

            // -------------------------------
            // Paso 1: Añadir encabezados de columna
            // -------------------------------
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                sb.Append(dt.Columns[i].ColumnName);
                if (i < dt.Columns.Count - 1) sb.Append(","); // Añadir coma excepto en la última columna
            }
            sb.AppendLine();

            // -------------------------------
            // Paso 2: Añadir filas
            // -------------------------------
            foreach (DataRow row in dt.Rows)
            {
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    string value;

                    // Formatear columnas DateTime como "yyyy-MM-dd"
                    if (dt.Columns[i].DataType == typeof(DateTime))
                    {
                        value = ((DateTime)row[i]).ToString("yyyy-MM-dd");
                    }
                    else
                    {
                        value = row[i].ToString();
                    }

                    // Escapar caracteres especiales: comas, comillas, saltos de línea
                    if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
                    {
                        value = "\"" + value.Replace("\"", "\"\"") + "\"";
                    }

                    sb.Append(value);

                    if (i < dt.Columns.Count - 1) sb.Append(",");
                }
                sb.AppendLine();
            }

            // -------------------------------
            // Paso 3: Escribir archivo CSV
            // -------------------------------
            File.WriteAllText(filePath, sb.ToString(), Encoding.UTF8);
        }
    }
}

CSV de salida

Método 2: Exportación de C# DataTable grande a CSV usando StreamWriter

Para DataTables grandes, usar StringBuilder puede consumir mucha memoria. StreamWriter te permite escribir filas línea por línea, lo cual es eficiente para grandes conjuntos de datos.

Pasos para la exportación de C# DataTable a CSV basada en StreamWriter

• Crea o recupera tu DataTable con los datos necesarios.
• Inicializa un StreamWriter con la ruta del archivo CSV de salida y la codificación deseada (como UTF-8).
• Escribe la fila de encabezado usando los nombres de las columnas del DataTable.
• Itera a través de las filas del DataTable y escribe cada línea en el archivo.
• Escapa los valores que contienen caracteres especiales (comas, comillas, saltos de línea) para mantener la integridad del CSV.
• Cierra el StreamWriter para liberar recursos del sistema.

Ejemplo de código

using System;
using System.Data;
using System.IO;
using System.Text;

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Paso 1: Crear un nuevo DataTable para este ejemplo
            // -------------------------------
            DataTable table = new DataTable("Products");

            // Definir columnas: ProductID, ProductName, Category, Price, Stock, LaunchDate
            table.Columns.Add("ProductID", typeof(int));
            table.Columns.Add("ProductName", typeof(string));
            table.Columns.Add("Category", typeof(string));
            table.Columns.Add("Price", typeof(decimal));
            table.Columns.Add("Stock", typeof(int));
            table.Columns.Add("LaunchDate", typeof(DateTime));

            // Añadir filas de muestra con productos variados
            table.Rows.Add(101, "Laptop Pro 15", "Electronics", 1500.99, 25, new DateTime(2023, 1, 10));
            table.Rows.Add(102, "Wireless Mouse", "Accessories", 29.95, 200, new DateTime(2022, 11, 5));
            table.Rows.Add(103, "Mechanical Keyboard", "Accessories", 79.99, 150, new DateTime(2022, 12, 1));
            table.Rows.Add(104, "4K Monitor", "Electronics", 399.50, 40, new DateTime(2023, 2, 20));
            table.Rows.Add(105, "USB-C Hub", "Accessories", 49.99, 300, new DateTime(2022, 9, 18));
            table.Rows.Add(106, "Gaming Chair", "Furniture", 259.99, 15, new DateTime(2023, 3, 5));

            // -------------------------------
            // Paso 2: Exportar DataTable a CSV usando StreamWriter
            // -------------------------------
            string csvPath = "products_stream.csv";
            DataTableToCsvStream(table, csvPath);

            Console.WriteLine($"Archivo CSV creado exitosamente: {csvPath}");
        }

        /// <summary>
        /// Exportar un DataTable a CSV usando StreamWriter (eficiente para grandes conjuntos de datos)
        /// </summary>
        /// <param name="dt">El DataTable a exportar</param>
        /// <param name="filePath">La ruta del archivo CSV a guardar</param>
        public static void DataTableToCsvStream(DataTable dt, string filePath)
        {
            // Usar StreamWriter para una escritura eficiente en memoria (fila por fila)
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.UTF8))
            {
                // -------------------------------
                // Paso 1: Escribir encabezados de columna
                // -------------------------------
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    writer.Write(dt.Columns[i].ColumnName);
                    if (i < dt.Columns.Count - 1)
                        writer.Write(","); // Añadir coma excepto en la última columna
                }
                writer.WriteLine();

                // -------------------------------
                // Paso 2: Escribir filas
                // -------------------------------
                foreach (DataRow row in dt.Rows)
                {
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        string value;

                        // Formatear DateTime como yyyy-MM-dd
                        if (dt.Columns[i].DataType == typeof(DateTime))
                        {
                            value = ((DateTime)row[i]).ToString("yyyy-MM-dd");
                        }
                        else
                        {
                            value = row[i].ToString();
                        }

                        // Escapar caracteres especiales: comas, comillas, saltos de línea
                        if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
                        {
                            value = "\"" + value.Replace("\"", "\"\"") + "\"";
                        }

                        writer.Write(value);

                        if (i < dt.Columns.Count - 1)
                            writer.Write(",");
                    }
                    writer.WriteLine();
                }
                // StreamWriter se cierra automáticamente al final del bloque using
            }
        }
    }
}

CSV de salida

Método 3: Usar Spire.XLS for .NET para convertir DataTable a CSV en C#

Para aplicaciones listas para producción, bibliotecas como Spire.XLS for .NET proporcionan una forma fiable y eficiente de manejar la exportación de C# DataTable a CSV. La biblioteca maneja automáticamente caracteres especiales, delimitadores y codificación, reduciendo el esfuerzo de codificación manual y asegurando una salida consistente y precisa.

Comenzar con Spire.XLS for .NET

Para usar Spire.XLS en tu proyecto de C#, instálalo a través de NuGet:

• Abre tu proyecto en Visual Studio.
• Ve a Herramientas -> Administrador de paquetes NuGet -> Administrar paquetes NuGet para la solución…
• Busca “Spire.XLS” y haz clic en Instalar.

Alternativamente, puedes instalarlo rápidamente usando la Consola del Administrador de Paquetes:

Install-Package Spire.XLS

Una vez instalado, puedes exportar DataTables a CSV sin esfuerzo y realizar operaciones adicionales en los archivos resultantes, como convertir CSV a Excel o importar CSV de nuevo a un DataTable, todo de manera eficiente dentro de tus aplicaciones .NET.

Pasos para la exportación de C# Datatable a CSV basada en Spire.XLS

• Prepara tu DataTable con los datos a exportar.
• Crea un objeto Workbook usando Spire.XLS.
• Inserta el DataTable en una hoja de cálculo.
• Guarda la hoja de cálculo como CSV, especificando el delimitador y la codificación.

Ejemplo de código

using Spire.Xls;
using System;
using System.Data;
using System.Text;

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Paso 1: Crear un nuevo DataTable para libros
            // -------------------------------
            DataTable dt = new DataTable("Books");

            // Definir columnas: BookID, Title, Author, Genre, Price, PublishDate
            dt.Columns.Add("BookID", typeof(int));
            dt.Columns.Add("Title", typeof(string));
            dt.Columns.Add("Author", typeof(string));
            dt.Columns.Add("Genre", typeof(string));
            dt.Columns.Add("Price", typeof(double));
            dt.Columns.Add("PublishDate", typeof(DateTime));

            // Añadir filas de muestra
            dt.Rows.Add(201, "The Great Gatsby", "F. Scott Fitzgerald", "Classic", 10.99, new DateTime(1925, 4, 10));
            dt.Rows.Add(202, "1984", "George Orwell", "Dystopian", 9.99, new DateTime(1949, 6, 8));
            dt.Rows.Add(203, "To Kill a Mockingbird", "Harper Lee", "Classic", 12.50, new DateTime(1960, 7, 11));
            dt.Rows.Add(204, "The Hobbit", "J.R.R. Tolkien", "Fantasy", 15.75, new DateTime(1937, 9, 21));
            dt.Rows.Add(205, "Clean Code", "Robert C. Martin", "Programming", 32.99, new DateTime(2008, 8, 1));
            dt.Rows.Add(206, "The Pragmatic Programmer", "Andrew Hunt", "Programming", 29.95, new DateTime(1999, 10, 20));

            // -------------------------------
            // Paso 2: Crear un Workbook e insertar DataTable
            // -------------------------------
            Workbook workbook = new Workbook();
            Worksheet sheet = workbook.Worksheets[0];

            // Insertar el DataTable en la hoja de cálculo comenzando desde la fila 1, columna 1
            // Incluir encabezados de columna
            sheet.InsertDataTable(dt, true, 1, 1);

            // -------------------------------
            // Paso 3: Guardar la hoja de cálculo como CSV
            // -------------------------------
            // Parámetros: nombre de archivo, delimitador, codificación
            sheet.SaveToFile("books.csv", ",", Encoding.UTF8);

            // Liberar recursos
            workbook.Dispose();
        }
    }
}

CSV de salida

Beneficios de usar Spire.XLS

• Manejo automático de caracteres especiales, delimitadores y codificaciones – no se necesita escape manual.
• Soporta tanto la importación como la exportación de CSV, lo que lo hace flexible para diferentes flujos de trabajo.
• Simplifica el código a nivel de producción – menos código repetitivo y menos errores en comparación con los métodos manuales.
• Escalable para grandes conjuntos de datos – funciona eficientemente incluso con miles de filas.

Comparación de rendimiento de los métodos de DataTable a CSV

Para comprender mejor las fortalezas y desventajas de cada enfoque, aquí hay una comparación lado a lado de StringBuilder, StreamWriter y Spire.XLS al exportar un DataTable a CSV.

¿Qué método deberías usar?

Si bien la tabla de comparación destaca las diferencias técnicas, elegir el método correcto depende de tu escenario específico, como el tamaño del conjunto de datos, los requisitos de rendimiento y las necesidades de producción.

• Elige StringBuilder si necesitas un control completo sobre el formato CSV y estás trabajando con conjuntos de datos de tamaño pequeño a mediano.
• Elige StreamWriter si estás exportando grandes conjuntos de datos y quieres una solución eficiente en memoria.
• Elige Spire.XLS si necesitas un enfoque listo para producción, fiable y de bajo mantenimiento, especialmente al manejar casos especiales o integrarlo en flujos de trabajo empresariales.

Manejo de casos especiales y mejores prácticas para DataTable a CSV

Al exportar un DataTable a CSV en C#, es importante seguir las mejores prácticas y también estar al tanto de algunos casos especiales que podrían afectar tu salida CSV. Manejarlos adecuadamente asegura que tus archivos estén limpios, sean fiables y fáciles de usar.

• Manejo de casos especiales    
  • Valores nulos – Reemplaza DBNull con cadenas vacías o marcadores de posición para que los datos faltantes no rompan tu CSV.
  • Delimitadores personalizados – Si tus datos contienen comas, considera usar ; o tabulaciones (\t) para evitar confusiones.
  • Caracteres especiales – Los valores con comillas, comas o saltos de línea deben escaparse adecuadamente para mantener la integridad del CSV.
  • Consideraciones de codificación – Se recomienda UTF-8 para la mayoría de los escenarios, pero algunos sistemas pueden requerir UTF-16 o ANSI.
  • Conjuntos de datos grandes – Para tablas muy grandes, considera dividir archivos o usar métodos eficientes en memoria como StreamWriter para evitar problemas de rendimiento.
• Mejores prácticas
  • Mantente con la codificación UTF-8 para compatibilidad entre plataformas y herramientas.
  • Prueba con casos especiales como nulos, comas, comillas y valores multilínea para prevenir errores inesperados.
  • Elige el método correcto – StringBuilder funciona bien para tablas pequeñas, StreamWriter es mejor para conjuntos de datos grandes, y Spire.XLS es ideal para soluciones listas para producción.
  • Documenta la estructura de tu CSV claramente para que otros sepan cómo interpretar los datos.

Conclusión

Dominar la conversión de C# DataTable a CSV es una habilidad esencial para los desarrolladores que trabajan con datos tabulares. Esta guía cubrió tres enfoques prácticos: usar StringBuilder para conjuntos de datos pequeños, emplear StreamWriter para un manejo eficiente y amigable con la memoria de tablas grandes, y aprovechar la biblioteca Spire.XLS para una solución fiable y lista para producción que gestiona automáticamente escenarios complejos.

Siguiendo estos ejemplos paso a paso, puedes realizar la conversión de C# DataTable a CSV con confianza, asegurando que tus datos sean precisos, compartibles y listos para la integración o análisis posterior.

Preguntas frecuentes

P1: ¿Cómo puedo convertir eficientemente un DataTable a CSV en C#?

R1: Puedes usar tres métodos: conversión manual con StringBuilder para conjuntos de datos pequeños, StreamWriter para conjuntos de datos grandes, o la biblioteca Spire.XLS para una solución lista para producción. Cada método asegura el manejo adecuado de comas, comillas y saltos de línea.

P2: ¿Cuál es la mejor manera de exportar grandes C# DataTables a CSV?

R2: Para grandes conjuntos de datos, se recomienda StreamWriter porque escribe filas línea por línea, reduciendo el uso de memoria. Spire.XLS es otra opción fiable para entornos de producción.

P3: ¿Cómo manejo caracteres especiales y valores nulos al exportar DataTable a CSV en C#?

R3: Siempre escapa comas, comillas y saltos de línea. Reemplaza valores nulos o DBNull con cadenas vacías o marcadores de posición. Usar Spire.XLS maneja automáticamente la mayoría de estos casos.

P4: ¿Puedo personalizar delimitadores y codificación al exportar un DataTable a CSV?

R4: Sí, puedes especificar delimitadores como ,, ; o \t y elegir codificación como UTF-8, UTF-16 o ANSI dependiendo de los requisitos del sistema.

P5: ¿Por qué debería usar Spire.XLS en lugar de métodos manuales o StreamWriter?

R5: Spire.XLS simplifica la exportación CSV al manejar el escape, los delimitadores y la codificación automáticamente, reduce la complejidad del código y es ideal para conjuntos de datos de tamaño mediano a grande o aplicaciones a nivel de producción.

P6: ¿Cómo aseguro que mi CSV exportado sea compatible con Excel y otras aplicaciones?

R6: Usa codificación UTF-8, escapa caracteres especiales y formatea los encabezados de manera consistente. Probar la salida en Excel u otras aplicaciones de destino ayuda a evitar problemas de compatibilidad.

Ver también

• C#/VB.NET: Convertir CSV a PDF
• C#/VB.NET: Convertir Excel a CSV
• Cómo convertir Excel (XLS o XLSX) a PDF en C# .NET
• C#/VB.NET: Convertir Excel a imágenes