Converter C# DataTable para CSV: 3 métodos fáceis com exemplos

Exportar DataTable para CSV em C# é um requisito comum para desenvolvedores que precisam salvar, compartilhar ou analisar dados tabulares de forma eficiente. O objeto DataTable no .NET fornece uma maneira estruturada de armazenar linhas e colunas na memória, mas muitas vezes você precisa converter esses dados em um arquivo CSV para o Excel, ferramentas de relatórios ou outros sistemas.

Este tutorial explica três métodos fáceis para exportar DataTable para CSV em C#, completos com instruções passo a passo e exemplos práticos de código. Esteja você trabalhando com pequenos conjuntos de dados ou tabelas grandes em nível de produção, essas abordagens ajudarão você a realizar a conversão de DataTable para CSV em C# de forma rápida e confiável.

Índice

• Por que Exportar DataTable para CSV em C#
• Método 1: Conversão Manual de DataTable C# para CSV Usando StringBuilder
• Método 2: Exportação de DataTable C# Grande para CSV Usando StreamWriter
• Método 3: Usar Spire.XLS for .NET para Converter DataTable para CSV em C#
• Comparação de Desempenho dos Métodos de DataTable para CSV
• Qual Método Você Deve Usar?
• Lidando com Casos Especiais e Melhores Práticas para DataTable para CSV
• Conclusão
• FAQs

Por que Exportar DataTable para CSV em C#

Exportar um DataTable para CSV em C# oferece várias vantagens principais:

• Formato de Dados Universal – CSV é suportado pelo Excel, Google Sheets, bancos de dados e muitas aplicações.
• Legível e Simples – Ao contrário de JSON ou XML, CSV é legível por humanos e fácil de editar manualmente.
• Integração Perfeita – Muitas aplicações empresariais, CRMs e ferramentas de relatórios aceitam arquivos CSV.
• Desempenho Rápido – A geração de CSV é leve e eficiente.
• Compatibilidade entre Plataformas – Arquivos CSV podem ser abertos e processados em qualquer sistema.

Método 1: Conversão Manual de DataTable C# para CSV Usando StringBuilder

Exportar manualmente um DataTable para CSV em C# usando StringBuilder oferece controle total sobre as regras de formatação e escape, tornando-o ideal para conjuntos de dados de pequeno a médio porte.

Passos para Converter DataTable para CSV em C# Usando StringBuilder

• Crie ou obtenha um DataTable de sua fonte (banco de dados, API ou manualmente).
• Inicialize um StringBuilder para armazenar o conteúdo CSV.
• Anexe cabeçalhos de coluna percorrendo DataTable.Columns.
• Percorra as linhas do DataTable e anexe o valor de cada célula.
• Faça o escape de caracteres especiais como vírgulas, aspas ou novas linhas.
• Escreva a string final em um arquivo CSV usando File.WriteAllText.

Exemplo de Código

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

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

            // Definir colunas: 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));

            // Adicionar linhas de exemplo com dados mais 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");

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

            Console.WriteLine($"Arquivo CSV criado com sucesso: {csvPath}");
        }

        /// <summary>
        /// Converte um DataTable para um arquivo CSV.
        /// </summary>
        /// <param name="dt">O DataTable a ser exportado</param>
        /// <param name="filePath">O caminho onde o arquivo CSV será salvo</param>
        public static void DataTableToCsv(DataTable dt, string filePath)
        {
            // Use StringBuilder para construir eficientemente o conteúdo CSV
            StringBuilder sb = new StringBuilder();

            // -------------------------------
            // Passo 1: Adicionar cabeçalhos de coluna
            // -------------------------------
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                sb.Append(dt.Columns[i].ColumnName);
                if (i < dt.Columns.Count - 1) sb.Append(","); // Adiciona vírgula, exceto na última coluna
            }
            sb.AppendLine();

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

                    // Formatar colunas 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();
                    }

                    // Escape de caracteres especiais: vírgulas, aspas, novas linhas
                    if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
                    {
                        value = "\"" + value.Replace("\"", "\"\"") + "\"";
                    }

                    sb.Append(value);

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

            // -------------------------------
            // Passo 3: Escrever arquivo CSV
            // -------------------------------
            File.WriteAllText(filePath, sb.ToString(), Encoding.UTF8);
        }
    }
}

Saída CSV

Método 2: Exportação de DataTable C# Grande para CSV Usando StreamWriter

Para DataTables grandes, usar o StringBuilder pode consumir muita memória. O StreamWriter permite que você escreva linhas linha por linha, o que é eficiente para grandes conjuntos de dados.

Passos para Exportação CSV de DataTable C# Baseada em StreamWriter

• Crie ou recupere seu DataTable com os dados necessários.
• Inicialize um StreamWriter com o caminho do arquivo CSV de saída e a codificação desejada (como UTF-8).
• Escreva a linha de cabeçalho usando os nomes das colunas do DataTable.
• Itere pelas linhas do DataTable e escreva cada linha no arquivo.
• Faça o escape de valores contendo caracteres especiais (vírgulas, aspas, novas linhas) para manter a integridade do CSV.
• Feche o StreamWriter para liberar recursos do sistema.

Exemplo de Código

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Passo 1: Criar um novo DataTable para este exemplo
            // -------------------------------
            DataTable table = new DataTable("Products");

            // Definir colunas: 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));

            // Adicionar linhas de exemplo com produtos 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));

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

            Console.WriteLine($"Arquivo CSV criado com sucesso: {csvPath}");
        }

        /// <summary>
        /// Exporta um DataTable para CSV usando StreamWriter (eficiente para grandes conjuntos de dados)
        /// </summary>
        /// <param name="dt">O DataTable a ser exportado</param>
        /// <param name="filePath">O caminho do arquivo CSV para salvar</param>
        public static void DataTableToCsvStream(DataTable dt, string filePath)
        {
            // Use StreamWriter para escrita eficiente em termos de memória (linha por linha)
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.UTF8))
            {
                // -------------------------------
                // Passo 1: Escrever cabeçalhos de coluna
                // -------------------------------
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    writer.Write(dt.Columns[i].ColumnName);
                    if (i < dt.Columns.Count - 1)
                        writer.Write(","); // Adiciona vírgula, exceto na última coluna
                }
                writer.WriteLine();

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

                        // Formatar 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();
                        }

                        // Escape de caracteres especiais: vírgulas, aspas, novas linhas
                        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 é fechado automaticamente no final do bloco using
            }
        }
    }
}

Saída CSV

Método 3: Usar Spire.XLS for .NET para Converter DataTable para CSV em C#

Para aplicações prontas para produção, bibliotecas como Spire.XLS for .NET fornecem uma maneira confiável e eficiente de lidar com a exportação de DataTable C# para CSV. A biblioteca lida automaticamente com caracteres especiais, delimitadores e codificação, reduzindo o esforço de codificação manual e garantindo uma saída consistente e precisa.

Comece com o Spire.XLS for .NET

Para usar o Spire.XLS em seu projeto C#, instale-o via NuGet:

• Abra seu projeto no Visual Studio.
• Vá para Ferramentas -> Gerenciador de Pacotes NuGet -> Gerenciar Pacotes NuGet para a Solução…
• Procure por “Spire.XLS” e clique em Instalar.

Alternativamente, você pode instalá-lo rapidamente usando o Console do Gerenciador de Pacotes:

Install-Package Spire.XLS

Uma vez instalado, você pode exportar DataTables para CSV sem esforço e realizar operações adicionais nos arquivos resultantes, como converter CSV para Excel ou importar CSV de volta para um DataTable, tudo de forma eficiente dentro de suas aplicações .NET.

Passos para Exportação de Datatable C# para CSV Baseada no Spire.XLS

• Prepare seu DataTable com os dados a serem exportados.
• Crie um objeto Workbook usando o Spire.XLS.
• Insira o DataTable em uma planilha.
• Salve a planilha como CSV, especificando o delimitador e a codificação.

Exemplo de Código

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Passo 1: Criar um novo DataTable para livros
            // -------------------------------
            DataTable dt = new DataTable("Books");

            // Definir colunas: 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));

            // Adicionar linhas de exemplo
            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));

            // -------------------------------
            // Passo 2: Criar um Workbook e inserir o DataTable
            // -------------------------------
            Workbook workbook = new Workbook();
            Worksheet sheet = workbook.Worksheets[0];

            // Inserir o DataTable na planilha começando da linha 1, coluna 1
            // Incluir cabeçalhos de coluna
            sheet.InsertDataTable(dt, true, 1, 1);

            // -------------------------------
            // Passo 3: Salvar a planilha como CSV
            // -------------------------------
            // Parâmetros: nome do arquivo, delimitador, codificação
            sheet.SaveToFile("books.csv", ",", Encoding.UTF8);

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

Saída CSV

Benefícios de Usar o Spire.XLS

• Manuseio automático de caracteres especiais, delimitadores e codificações – não é necessário fazer escape manual.
• Suporta tanto a importação quanto a exportação de CSV, tornando-o flexível para diferentes fluxos de trabalho.
• Simplifica o código em nível de produção – menos código repetitivo e menos erros em comparação com os métodos manuais.
• Escalável para grandes conjuntos de dados – funciona eficientemente mesmo com milhares de linhas.

Comparação de Desempenho dos Métodos de DataTable para CSV

Para entender melhor os pontos fortes e as desvantagens de cada abordagem, aqui está uma comparação lado a lado do StringBuilder, StreamWriter e Spire.XLS ao exportar um DataTable para CSV.

Qual Método Você Deve Usar?

Embora a tabela de comparação destaque as diferenças técnicas, a escolha do método certo depende do seu cenário específico, como tamanho do conjunto de dados, requisitos de desempenho e necessidades de produção.

• Escolha o StringBuilder se você precisar de controle completo sobre a formatação CSV e estiver trabalhando com conjuntos de dados de pequeno a médio porte.
• Escolha o StreamWriter se você estiver exportando grandes conjuntos de dados e quiser uma solução eficiente em termos de memória.
• Escolha o Spire.XLS se você precisar de uma abordagem pronta para produção, confiável e de baixa manutenção, especialmente ao lidar com casos especiais ou integrar em fluxos de trabalho empresariais.

Lidando com Casos Especiais e Melhores Práticas para DataTable para CSV

Ao exportar um DataTable para CSV em C#, é importante seguir as melhores práticas e também estar ciente de alguns casos especiais que podem afetar sua saída CSV. Lidar com eles adequadamente garante que seus arquivos sejam limpos, confiáveis e fáceis de usar.

• Lidando com Casos Especiais    
  • Valores nulos – Substitua DBNull por strings vazias ou placeholders para que dados ausentes não quebrem seu CSV.
  • Delimitadores personalizados – Se seus dados contêm vírgulas, considere usar ; ou tabs (\t) para evitar confusão.
  • Caracteres especiais – Valores com aspas, vírgulas ou quebras de linha devem ter o escape adequado para manter a integridade do CSV.
  • Considerações sobre codificação – UTF-8 é recomendado para a maioria dos cenários, mas alguns sistemas podem exigir UTF-16 ou ANSI.
  • Grandes conjuntos de dados – Para tabelas muito grandes, considere dividir arquivos ou usar métodos eficientes em termos de memória como o StreamWriter para evitar problemas de desempenho.
• Melhores Práticas
  • Mantenha a codificação UTF-8 para compatibilidade entre plataformas e ferramentas.
  • Teste com casos especiais como nulos, vírgulas, aspas e valores de várias linhas para evitar erros inesperados.
  • Escolha o método certo – StringBuilder funciona bem para tabelas pequenas, StreamWriter é melhor para grandes conjuntos de dados e Spire.XLS é ideal para soluções prontas para produção.
  • Documente sua estrutura CSV claramente para que outros saibam como interpretar os dados.

Conclusão

Dominar a conversão de DataTable C# para CSV é uma habilidade essencial para desenvolvedores que trabalham com dados tabulares. Este guia cobriu três abordagens práticas: usar o StringBuilder para pequenos conjuntos de dados, empregar o StreamWriter para manuseio eficiente e amigável à memória de tabelas grandes, e aproveitar a biblioteca Spire.XLS para uma solução confiável e pronta para produção que gerencia automaticamente cenários complexos.

Seguindo estes exemplos passo a passo, você pode realizar a conversão de DataTable C# para CSV com confiança, garantindo que seus dados sejam precisos, compartilháveis e prontos para integração ou análise posterior.

FAQs

Q1: Como posso converter um DataTable para CSV em C# eficientemente?

A1: Você pode usar três métodos: conversão manual com StringBuilder para pequenos conjuntos de dados, StreamWriter para grandes conjuntos de dados, ou a biblioteca Spire.XLS para uma solução pronta para produção. Cada método garante o manuseio adequado de vírgulas, aspas e novas linhas.

Q2: Qual é a melhor maneira de exportar grandes DataTables C# para CSV?

A2: Para grandes conjuntos de dados, o StreamWriter é recomendado porque escreve linhas linha por linha, reduzindo o uso de memória. O Spire.XLS é outra opção confiável para ambientes de produção.

Q3: Como lidar com caracteres especiais e valores nulos ao exportar DataTable para CSV em C#?

A3: Sempre faça o escape de vírgulas, aspas e quebras de linha. Substitua valores nulos ou DBNull por strings vazias ou placeholders. Usar o Spire.XLS lida automaticamente com a maioria desses casos.

Q4: Posso personalizar delimitadores e codificação ao exportar um DataTable para CSV?

A4: Sim, você pode especificar delimitadores como ,, ; ou \t e escolher codificação como UTF-8, UTF-16 ou ANSI, dependendo dos requisitos do sistema.

Q5: Por que devo usar o Spire.XLS em vez dos métodos manuais ou StreamWriter?

A5: O Spire.XLS simplifica a exportação de CSV lidando automaticamente com escape, delimitadores e codificação, reduz a complexidade do código e é ideal para conjuntos de dados de médio a grande porte ou aplicações em nível de produção.

Q6: Como garanto que meu CSV exportado seja compatível com o Excel e outras aplicações?

A6: Use a codificação UTF-8, faça o escape de caracteres especiais e formate os cabeçalhos de forma consistente. Testar a saída no Excel ou em outras aplicações de destino ajuda a evitar problemas de compatibilidade.

Veja Também

• C#/VB.NET: Converter CSV para PDF
• C#/VB.NET: Converter Excel para CSV
• Como Converter Excel (XLS ou XLSX) para PDF em C# .NET
• C#/VB.NET: Converter Excel para Imagens