Convertire C# DataTable in CSV: 3 metodi semplici con esempi

Esportare DataTable in CSV in C# è un requisito comune per gli sviluppatori che necessitano di salvare, condividere o analizzare dati tabulari in modo efficiente. L'oggetto DataTable in .NET fornisce un modo strutturato per archiviare righe e colonne in memoria, ma spesso è necessario convertire questi dati in un file CSV per Excel, strumenti di reporting o altri sistemi.

Questo tutorial spiega tre semplici metodi per esportare DataTable in CSV in C#, completi di istruzioni dettagliate ed esempi pratici di codice. Sia che tu stia lavorando con piccoli set di dati o tabelle di grandi dimensioni a livello di produzione, questi approcci ti aiuteranno a eseguire la conversione da DataTable a CSV in C# in modo rapido e affidabile.

Indice dei contenuti

• Perché Esportare DataTable in CSV in C#
• Metodo 1: Conversione Manuale DataTable C# in CSV Usando StringBuilder
• Metodo 2: Esportazione DataTable C# di Grandi Dimensioni in CSV Usando StreamWriter
• Metodo 3: Usare Spire.XLS for .NET per Convertire DataTable in CSV in C#
• Confronto delle Prestazioni dei Metodi da DataTable a CSV
• Quale Metodo Dovresti Usare?
• Gestione di Casi Speciali e Migliori Pratiche per DataTable in CSV
• Conclusione
• FAQs

Perché Esportare DataTable in CSV in C#

Esportare un DataTable in CSV in C# offre diversi vantaggi chiave:

• Formato Dati Universale – Il CSV è supportato da Excel, Google Sheets, database e molte applicazioni.
• Leggibile e Semplice – A differenza di JSON o XML, il CSV è leggibile dall'uomo e facile da modificare manualmente.
• Integrazione Perfetta – Molte applicazioni aziendali, CRM e strumenti di reporting accettano file CSV.
• Prestazioni Veloci – La generazione di CSV è leggera ed efficiente.
• Compatibilità Multipiattaforma – I file CSV possono essere aperti ed elaborati su qualsiasi sistema.

Metodo 1: Conversione Manuale DataTable C# in CSV Usando StringBuilder

Esportare manualmente un DataTable in CSV in C# usando StringBuilder ti dà il pieno controllo sulla formattazione e sulle regole di escape, rendendolo ideale per set di dati di piccole e medie dimensioni.

Passaggi per Convertire DataTable in CSV in C# Usando StringBuilder

• Crea o recupera un DataTable dalla tua fonte (database, API o manualmente).
• Inizializza uno StringBuilder per archiviare il contenuto CSV.
• Aggiungi le intestazioni di colonna scorrendo DataTable.Columns.
• Scorri le righe del DataTable e aggiungi il valore di ciascuna cella.
• Esegui l'escape dei caratteri speciali come virgole, virgolette o nuove righe.
• Scrivi la stringa finale in un file CSV usando File.WriteAllText.

Codice di Esempio

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

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

            // Definire le colonne: 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));

            // Aggiungere righe di esempio con dati più ricchi
            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");

            // -------------------------------
            // Passaggio 2: Esportare DataTable in CSV
            // -------------------------------
            string csvPath = "employees.csv";
            DataTableToCsv(table, csvPath);

            Console.WriteLine($"File CSV creato con successo: {csvPath}");
        }

        /// <summary>
        /// Converte un DataTable in un file CSV.
        /// </summary>
        /// <param name="dt">Il DataTable da esportare</param>
        /// <param name="filePath">Il percorso in cui verrà salvato il file CSV</param>
        public static void DataTableToCsv(DataTable dt, string filePath)
        {
            // Usa StringBuilder per costruire in modo efficiente il contenuto CSV
            StringBuilder sb = new StringBuilder();

            // -------------------------------
            // Passaggio 1: Aggiungere le intestazioni di colonna
            // -------------------------------
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                sb.Append(dt.Columns[i].ColumnName);
                if (i < dt.Columns.Count - 1) sb.Append(","); // Aggiungi la virgola tranne che per l'ultima colonna
            }
            sb.AppendLine();

            // -------------------------------
            // Passaggio 2: Aggiungere le righe
            // -------------------------------
            foreach (DataRow row in dt.Rows)
            {
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    string value;

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

                    // Escape dei caratteri speciali: virgole, virgolette, nuove righe
                    if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
                    {
                        value = "\"" + value.Replace("\"", "\"\"") + "\"";
                    }

                    sb.Append(value);

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

            // -------------------------------
            // Passaggio 3: Scrivere il file CSV
            // -------------------------------
            File.WriteAllText(filePath, sb.ToString(), Encoding.UTF8);
        }
    }
}

Output CSV

Metodo 2: Esportazione DataTable C# di Grandi Dimensioni in CSV Usando StreamWriter

Per DataTable di grandi dimensioni, l'uso di StringBuilder può essere intensivo in termini di memoria. StreamWriter ti permette di scrivere righe riga per riga, il che è efficiente per grandi set di dati.

Passaggi per l'Esportazione CSV di DataTable C# Basata su StreamWriter

• Crea o recupera il tuo DataTable con i dati necessari.
• Inizializza uno StreamWriter con il percorso del file CSV di output e la codifica desiderata (come UTF-8).
• Scrivi la riga di intestazione usando i nomi delle colonne del DataTable.
• Itera attraverso le righe del DataTable e scrivi ogni riga sul file.
• Esegui l'escape dei valori contenenti caratteri speciali (virgole, virgolette, nuove righe) per mantenere l'integrità del CSV.
• Chiudi lo StreamWriter per rilasciare le risorse di sistema.

Codice di Esempio

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Passaggio 1: Creare un nuovo DataTable per questo esempio
            // -------------------------------
            DataTable table = new DataTable("Products");

            // Definire le colonne: 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));

            // Aggiungere righe di esempio con prodotti vari
            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));

            // -------------------------------
            // Passaggio 2: Esportare DataTable in CSV usando StreamWriter
            // -------------------------------
            string csvPath = "products_stream.csv";
            DataTableToCsvStream(table, csvPath);

            Console.WriteLine($"File CSV creato con successo: {csvPath}");
        }

        /// <summary>
        /// Esporta un DataTable in CSV usando StreamWriter (efficiente per grandi set di dati)
        /// </summary>
        /// <param name="dt">Il DataTable da esportare</param>
        /// <param name="filePath">Il percorso del file CSV da salvare</param>
        public static void DataTableToCsvStream(DataTable dt, string filePath)
        {
            // Usa StreamWriter per una scrittura efficiente in termini di memoria (riga per riga)
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.UTF8))
            {
                // -------------------------------
                // Passaggio 1: Scrivere le intestazioni di colonna
                // -------------------------------
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    writer.Write(dt.Columns[i].ColumnName);
                    if (i < dt.Columns.Count - 1)
                        writer.Write(","); // Aggiungi la virgola tranne che per l'ultima colonna
                }
                writer.WriteLine();

                // -------------------------------
                // Passaggio 2: Scrivere le righe
                // -------------------------------
                foreach (DataRow row in dt.Rows)
                {
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        string value;

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

                        // Escape dei caratteri speciali: virgole, virgolette, nuove righe
                        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 viene chiuso automaticamente alla fine del blocco using
            }
        }
    }
}

Output CSV

Metodo 3: Usare Spire.XLS for .NET per Convertire DataTable in CSV in C#

Per applicazioni pronte per la produzione, librerie come Spire.XLS for .NET forniscono un modo affidabile ed efficiente per gestire l'esportazione da DataTable C# a CSV. La libreria gestisce automaticamente caratteri speciali, delimitatori e codifica, riducendo lo sforzo di codifica manuale e garantendo un output coerente e accurato.

Inizia con Spire.XLS for .NET

Per usare Spire.XLS nel tuo progetto C#, installalo tramite NuGet:

• Apri il tuo progetto in Visual Studio.
• Vai su Strumenti -> Gestione pacchetti NuGet -> Gestisci pacchetti NuGet per la soluzione…
• Cerca “Spire.XLS” e fai clic su Installa.

In alternativa, puoi installarlo rapidamente usando la Console di Gestione Pacchetti:

Install-Package Spire.XLS

Una volta installato, puoi esportare senza sforzo DataTable in CSV ed eseguire ulteriori operazioni sui file risultanti, come convertire CSV in Excel o importare CSV di nuovo in un DataTable, tutto in modo efficiente all'interno delle tue applicazioni .NET.

Passaggi per l'Esportazione da Datatable C# a CSV Basata su Spire.XLS

• Prepara il tuo DataTable con i dati da esportare.
• Crea un oggetto Workbook usando Spire.XLS.
• Inserisci il DataTable in un foglio di lavoro.
• Salva il foglio di lavoro come CSV, specificando delimitatore e codifica.

Codice di Esempio

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Passaggio 1: Creare un nuovo DataTable per i libri
            // -------------------------------
            DataTable dt = new DataTable("Books");

            // Definire le colonne: 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));

            // Aggiungere righe di esempio
            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));

            // -------------------------------
            // Passaggio 2: Creare un Workbook e inserire il DataTable
            // -------------------------------
            Workbook workbook = new Workbook();
            Worksheet sheet = workbook.Worksheets[0];

            // Inserire il DataTable nel foglio di lavoro partendo dalla riga 1, colonna 1
            // Includere le intestazioni di colonna
            sheet.InsertDataTable(dt, true, 1, 1);

            // -------------------------------
            // Passaggio 3: Salvare il foglio di lavoro come CSV
            // -------------------------------
            // Parametri: nome file, delimitatore, codifica
            sheet.SaveToFile("books.csv", ",", Encoding.UTF8);

            // Rilasciare le risorse
            workbook.Dispose();
        }
    }
}

Output CSV

Vantaggi dell'utilizzo di Spire.XLS

• Gestione automatica di caratteri speciali, delimitatori e codifiche – non è necessario alcun escape manuale.
• Supporta sia l'importazione che l'esportazione di CSV, rendendolo flessibile per diversi flussi di lavoro.
• Semplifica il codice a livello di produzione – meno codice boilerplate e meno errori rispetto ai metodi manuali.
• Scalabile per grandi set di dati – funziona in modo efficiente anche con migliaia di righe.

Confronto delle Prestazioni dei Metodi da DataTable a CSV

Per comprendere meglio i punti di forza e i compromessi di ciascun approccio, ecco un confronto fianco a fianco di StringBuilder, StreamWriter e Spire.XLS durante l'esportazione di un DataTable in CSV.

Quale Metodo Dovresti Usare?

Mentre la tabella di confronto evidenzia le differenze tecniche, la scelta del metodo giusto dipende dal tuo scenario specifico, come le dimensioni del set di dati, i requisiti di prestazione e le esigenze di produzione.

• Scegli StringBuilder se hai bisogno di un controllo completo sulla formattazione CSV e stai lavorando con set di dati di piccole e medie dimensioni.
• Scegli StreamWriter se stai esportando grandi set di dati e desideri una soluzione efficiente in termini di memoria.
• Scegli Spire.XLS se hai bisogno di un approccio affidabile, pronto per la produzione e a bassa manutenzione, specialmente quando si gestiscono casi speciali o si integra in flussi di lavoro aziendali.

Gestione di Casi Speciali e Migliori Pratiche per DataTable in CSV

Quando si esporta un DataTable in CSV in C#, è importante seguire le migliori pratiche ed essere consapevoli di alcuni casi speciali che potrebbero influenzare l'output CSV. Gestirli correttamente garantisce che i file siano puliti, affidabili e facili da usare.

• Gestione di Casi Speciali    
  • Valori nulli – Sostituisci DBNull con stringhe vuote o segnaposto in modo che i dati mancanti non rompano il tuo CSV.
  • Delimitatori personalizzati – Se i tuoi dati contengono virgole, considera l'uso di ; o tab (\t) per evitare confusione.
  • Caratteri speciali – I valori con virgolette, virgole o interruzioni di riga dovrebbero essere correttamente sottoposti a escape per mantenere l'integrità del CSV.
  • Considerazioni sulla codifica – UTF-8 è raccomandato per la maggior parte degli scenari, ma alcuni sistemi potrebbero richiedere UTF-16 o ANSI.
  • Set di dati di grandi dimensioni – Per tabelle molto grandi, considera la suddivisione dei file o l'uso di metodi efficienti in termini di memoria come StreamWriter per evitare problemi di prestazioni.
• Migliori Pratiche
  • Attieniti alla codifica UTF-8 per la compatibilità tra piattaforme e strumenti.
  • Testa con casi speciali come null, virgole, virgolette e valori multilinea per prevenire errori imprevisti.
  • Scegli il metodo giusto – StringBuilder va bene per tabelle piccole, StreamWriter è migliore per grandi set di dati e Spire.XLS è ideale per soluzioni pronte per la produzione.
  • Documenta chiaramente la tua struttura CSV in modo che altri sappiano come interpretare i dati.

Conclusione

Padroneggiare la conversione da DataTable C# a CSV è un'abilità essenziale per gli sviluppatori che lavorano con dati tabulari. Questa guida ha coperto tre approcci pratici: l'uso di StringBuilder per piccoli set di dati, l'impiego di StreamWriter per una gestione efficiente e rispettosa della memoria di tabelle di grandi dimensioni, e lo sfruttamento della libreria Spire.XLS per una soluzione affidabile e pronta per la produzione che gestisce automaticamente scenari complessi.

Seguendo questi esempi passo-passo, puoi eseguire la conversione da DataTable C# a CSV con sicurezza, assicurando che i tuoi dati siano accurati, condivisibili e pronti per l'integrazione o ulteriori analisi.

FAQs

Q1: Come posso convertire un DataTable in CSV in C# in modo efficiente?

A1: Puoi usare tre metodi: conversione manuale con StringBuilder per piccoli set di dati, StreamWriter per grandi set di dati, o la libreria Spire.XLS per una soluzione pronta per la produzione. Ogni metodo garantisce una gestione corretta di virgole, virgolette e nuove righe.

Q2: Qual è il modo migliore per esportare grandi DataTable C# in CSV?

A2: Per grandi set di dati, si raccomanda StreamWriter perché scrive le righe riga per riga, riducendo l'utilizzo della memoria. Spire.XLS è un'altra opzione affidabile per ambienti di produzione.

Q3: Come gestisco i caratteri speciali e i valori nulli durante l'esportazione di DataTable in CSV in C#?

A3: Esegui sempre l'escape di virgole, virgolette e interruzioni di riga. Sostituisci i valori null o DBNull con stringhe vuote o segnaposto. L'uso di Spire.XLS gestisce automaticamente la maggior parte di questi casi.

Q4: Posso personalizzare i delimitatori e la codifica durante l'esportazione di un DataTable in CSV?

A4: Sì, puoi specificare delimitatori come ,, ; o \t e scegliere la codifica come UTF-8, UTF-16 o ANSI a seconda dei requisiti di sistema.

Q5: Perché dovrei usare Spire.XLS invece dei metodi manuali o StreamWriter?

A5: Spire.XLS semplifica l'esportazione CSV gestendo automaticamente l'escape, i delimitatori e la codifica, riduce la complessità del codice ed è ideale per set di dati di medie e grandi dimensioni o applicazioni a livello di produzione.

Q6: Come mi assicuro che il mio CSV esportato sia compatibile con Excel e altre applicazioni?

A6: Usa la codifica UTF-8, esegui l'escape dei caratteri speciali e formatta le intestazioni in modo coerente. Testare l'output in Excel o altre applicazioni di destinazione aiuta a evitare problemi di compatibilità.

Vedi Anche

• C#/VB.NET: Convertire CSV in PDF
• C#/VB.NET: Convertire Excel in CSV
• Come Convertire Excel (XLS o XLSX) in PDF in C# .NET
• C#/VB.NET: Convertire Excel in Immagini