Convertir C# DataTable en CSV : 3 méthodes faciles avec exemples

L'exportation de DataTable en CSV en C# est une exigence courante pour les développeurs qui ont besoin de sauvegarder, partager ou analyser efficacement des données tabulaires. L'objet DataTable dans .NET fournit un moyen structuré de stocker des lignes et des colonnes en mémoire, mais vous avez souvent besoin de convertir ces données en un fichier CSV pour Excel, des outils de reporting ou d'autres systèmes.

Ce tutoriel explique trois méthodes faciles pour exporter DataTable en CSV en C#, complétées par des instructions étape par étape et des exemples de code pratiques. Que vous travailliez avec de petits ensembles de données ou de grandes tables de niveau production, ces approches vous aideront à effectuer la conversion de DataTable en CSV en C# rapidement et de manière fiable.

Table des matières

• Pourquoi exporter DataTable en CSV en C#
• Méthode 1 : Conversion manuelle de C# DataTable en CSV à l'aide de StringBuilder
• Méthode 2 : Exportation de C# DataTable volumineux en CSV à l'aide de StreamWriter
• Méthode 3 : Utiliser Spire.XLS for .NET pour convertir DataTable en CSV en C#
• Comparaison des performances des méthodes de DataTable en CSV
• Quelle méthode devriez-vous utiliser ?
• Gestion des cas spéciaux et meilleures pratiques pour DataTable en CSV
• Conclusion
• FAQ

Pourquoi exporter DataTable en CSV en C#

L'exportation d'un DataTable en CSV en C# offre plusieurs avantages clés :

• Format de données universel – CSV est pris en charge par Excel, Google Sheets, les bases de données et de nombreuses applications.
• Lisible et simple – Contrairement à JSON ou XML, CSV est lisible par l'homme et facile à modifier manuellement.
• Intégration transparente – De nombreuses applications d'entreprise, CRM et outils de reporting acceptent les fichiers CSV.
• Performances rapides – La génération de CSV est légère et efficace.
• Compatibilité multiplateforme – Les fichiers CSV peuvent être ouverts et traités sur n'importe quel système.

Méthode 1 : Conversion manuelle de C# DataTable en CSV à l'aide de StringBuilder

L'exportation manuelle d'un DataTable en CSV en C# à l'aide de StringBuilder vous donne un contrôle total sur les règles de formatage et d'échappement, ce qui le rend idéal pour les ensembles de données de petite à moyenne taille.

Étapes pour convertir DataTable en CSV en C# à l'aide de StringBuilder

• Créez ou récupérez un DataTable depuis votre source (base de données, API ou manuellement).
• Initialisez un StringBuilder pour stocker le contenu CSV.
• Ajoutez les en-têtes de colonnes en parcourant DataTable.Columns.
• Parcourez les lignes de DataTable et ajoutez la valeur de chaque cellule.
• Échappez les caractères spéciaux comme les virgules, les guillemets ou les sauts de ligne.
• Écrivez la chaîne finale dans un fichier CSV à l'aide de File.WriteAllText.

Exemple de code

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Étape 1 : Créer un DataTable
            // -------------------------------
            DataTable table = new DataTable("Employees");

            // Définir les colonnes : 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));

            // Ajouter des exemples de lignes avec des données plus riches
            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");

            // -------------------------------
            // Étape 2 : Exporter DataTable en CSV
            // -------------------------------
            string csvPath = "employees.csv";
            DataTableToCsv(table, csvPath);

            Console.WriteLine($"Fichier CSV créé avec succès : {csvPath}");
        }

        /// <summary>
        /// Convertit un DataTable en fichier CSV.
        /// </summary>
        /// <param name="dt">Le DataTable à exporter</param>
        /// <param name="filePath">Le chemin où le fichier CSV sera enregistré</param>
        public static void DataTableToCsv(DataTable dt, string filePath)
        {
            // Utiliser StringBuilder pour construire efficacement le contenu CSV
            StringBuilder sb = new StringBuilder();

            // -------------------------------
            // Étape 1 : Ajouter les en-têtes de colonnes
            // -------------------------------
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                sb.Append(dt.Columns[i].ColumnName);
                if (i < dt.Columns.Count - 1) sb.Append(","); // Ajouter une virgule sauf pour la dernière colonne
            }
            sb.AppendLine();

            // -------------------------------
            // Étape 2 : Ajouter les lignes
            // -------------------------------
            foreach (DataRow row in dt.Rows)
            {
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    string value;

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

                    // Échapper les caractères spéciaux : virgules, guillemets, sauts de ligne
                    if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
                    {
                        value = "\"" + value.Replace("\"", "\"\"") + "\"";
                    }

                    sb.Append(value);

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

            // -------------------------------
            // Étape 3 : Écrire le fichier CSV
            // -------------------------------
            File.WriteAllText(filePath, sb.ToString(), Encoding.UTF8);
        }
    }
}

CSV de sortie

Méthode 2 : Exportation de C# DataTable volumineux en CSV à l'aide de StreamWriter

Pour les DataTables volumineux, l'utilisation de StringBuilder peut être gourmande en mémoire. StreamWriter vous permet d'écrire les lignes une par une, ce qui est efficace pour les grands ensembles de données.

Étapes pour l'exportation C# DataTable CSV basée sur StreamWriter

• Créez ou récupérez votre DataTable avec les données nécessaires.
• Initialisez un StreamWriter avec le chemin du fichier CSV de sortie et l'encodage souhaité (comme UTF-8).
• Écrivez la ligne d'en-tête en utilisant les noms de colonnes du DataTable.
• Itérez à travers les lignes du DataTable et écrivez chaque ligne dans le fichier.
• Échappez les valeurs contenant des caractères spéciaux (virgules, guillemets, sauts de ligne) pour maintenir l'intégrité du CSV.
• Fermez le StreamWriter pour libérer les ressources système.

Exemple de code

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Étape 1 : Créer un nouveau DataTable pour cet exemple
            // -------------------------------
            DataTable table = new DataTable("Products");

            // Définir les colonnes : 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));

            // Ajouter des exemples de lignes avec des produits variés
            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));

            // -------------------------------
            // Étape 2 : Exporter DataTable en CSV à l'aide de StreamWriter
            // -------------------------------
            string csvPath = "products_stream.csv";
            DataTableToCsvStream(table, csvPath);

            Console.WriteLine($"Fichier CSV créé avec succès : {csvPath}");
        }

        /// <summary>
        /// Exporter un DataTable en CSV à l'aide de StreamWriter (efficace pour les grands ensembles de données)
        /// </summary>
        /// <param name="dt">Le DataTable à exporter</param>
        /// <param name="filePath">Le chemin du fichier CSV à enregistrer</param>
        public static void DataTableToCsvStream(DataTable dt, string filePath)
        {
            // Utiliser StreamWriter pour une écriture efficace en mémoire (ligne par ligne)
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.UTF8))
            {
                // -------------------------------
                // Étape 1 : Écrire les en-têtes de colonnes
                // -------------------------------
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    writer.Write(dt.Columns[i].ColumnName);
                    if (i < dt.Columns.Count - 1)
                        writer.Write(","); // Ajouter une virgule sauf pour la dernière colonne
                }
                writer.WriteLine();

                // -------------------------------
                // Étape 2 : Écrire les lignes
                // -------------------------------
                foreach (DataRow row in dt.Rows)
                {
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        string value;

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

                        // Échapper les caractères spéciaux : virgules, guillemets, sauts de ligne
                        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 est automatiquement fermé à la fin du bloc using
            }
        }
    }
}

CSV de sortie

Méthode 3 : Utiliser Spire.XLS for .NET pour convertir DataTable en CSV en C#

Pour les applications prêtes pour la production, des bibliothèques comme Spire.XLS for .NET fournissent un moyen fiable et efficace de gérer l'exportation de C# DataTable en CSV. La bibliothèque gère automatiquement les caractères spéciaux, les délimiteurs et l'encodage, réduisant ainsi l'effort de codage manuel et garantissant une sortie cohérente et précise.

Démarrer avec Spire.XLS for .NET

Pour utiliser Spire.XLS dans votre projet C#, installez-le via NuGet:

• Ouvrez votre projet dans Visual Studio.
• Allez dans Outils -> Gestionnaire de paquets NuGet -> Gérer les paquets NuGet pour la solution…
• Recherchez “Spire.XLS” et cliquez sur Installer.

Alternativement, vous pouvez l'installer rapidement à l'aide de la console du gestionnaire de paquets :

Install-Package Spire.XLS

Une fois installé, vous pouvez exporter sans effort des DataTables en CSV et effectuer d'autres opérations sur les fichiers résultants, telles que la conversion de CSV en Excel ou l'importation de CSV dans un DataTable, le tout efficacement au sein de vos applications .NET.

Étapes pour l'exportation C# Datatable vers CSV basée sur Spire.XLS

• Préparez votre DataTable avec les données à exporter.
• Créez un objet Workbook à l'aide de Spire.XLS.
• Insérez le DataTable dans une feuille de calcul.
• Enregistrez la feuille de calcul au format CSV, en spécifiant le délimiteur et l'encodage.

Exemple de code

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

namespace DataTableToCSV
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // -------------------------------
            // Étape 1 : Créer un nouveau DataTable pour les livres
            // -------------------------------
            DataTable dt = new DataTable("Books");

            // Définir les colonnes : 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));

            // Ajouter des exemples de lignes
            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));

            // -------------------------------
            // Étape 2 : Créer un classeur et insérer DataTable
            // -------------------------------
            Workbook workbook = new Workbook();
            Worksheet sheet = workbook.Worksheets[0];

            // Insérer le DataTable dans la feuille de calcul à partir de la ligne 1, colonne 1
            // Inclure les en-têtes de colonnes
            sheet.InsertDataTable(dt, true, 1, 1);

            // -------------------------------
            // Étape 3 : Enregistrer la feuille de calcul au format CSV
            // -------------------------------
            // Paramètres : nom de fichier, délimiteur, encodage
            sheet.SaveToFile("books.csv", ",", Encoding.UTF8);

            // Libérer les ressources
            workbook.Dispose();
        }
    }
}

CSV de sortie

Avantages de l'utilisation de Spire.XLS

• Gestion automatique des caractères spéciaux, des délimiteurs et des encodages – aucun échappement manuel n'est nécessaire.
• Prend en charge à la fois l'importation et l'exportation CSV, ce qui le rend flexible pour différents flux de travail.
• Simplifie le code de niveau production – moins de code standard et moins d'erreurs par rapport aux méthodes manuelles.
• Évolutif pour les grands ensembles de données – fonctionne efficacement même avec des milliers de lignes.

Comparaison des performances des méthodes de DataTable en CSV

Pour mieux comprendre les points forts et les compromis de chaque approche, voici une comparaison côte à côte de StringBuilder, StreamWriter et Spire.XLS lors de l'exportation d'un DataTable en CSV.

Quelle méthode devriez-vous utiliser ?

Bien que le tableau de comparaison mette en évidence les différences techniques, le choix de la bonne méthode dépend de votre scénario spécifique, tel que la taille de l'ensemble de données, les exigences de performance et les besoins de production.

• Choisissez StringBuilder si vous avez besoin d'un contrôle complet sur le formatage CSV et que vous travaillez avec des ensembles de données de petite à moyenne taille.
• Choisissez StreamWriter si vous exportez de grands ensembles de données et souhaitez une solution efficace en mémoire.
• Choisissez Spire.XLS si vous avez besoin d'une approche fiable, prête pour la production et nécessitant peu d'entretien, en particulier lors de la gestion de cas spéciaux ou de l'intégration dans des flux de travail d'entreprise.

Gestion des cas spéciaux et meilleures pratiques pour DataTable en CSV

Lors de l'exportation d'un DataTable en CSV en C#, il est important de suivre les meilleures pratiques et d'être conscient de certains cas spéciaux qui pourraient affecter votre sortie CSV. Une gestion appropriée garantit que vos fichiers sont propres, fiables et faciles à utiliser.

• Gestion des cas spéciaux    
  • Valeurs nulles – Remplacez DBNull par des chaînes vides ou des espaces réservés afin que les données manquantes ne cassent pas votre CSV.
  • Délimiteurs personnalisés – Si vos données contiennent des virgules, envisagez d'utiliser ; ou des tabulations (\t) pour éviter toute confusion.
  • Caractères spéciaux – Les valeurs avec des guillemets, des virgules ou des sauts de ligne doivent être correctement échappées pour maintenir l'intégrité du CSV.
  • Considérations sur l'encodage – UTF-8 est recommandé pour la plupart des scénarios, mais certains systèmes peuvent nécessiter UTF-16 ou ANSI.
  • Grands ensembles de données – Pour les très grandes tables, envisagez de diviser les fichiers ou d'utiliser des méthodes économes en mémoire comme StreamWriter pour éviter les problèmes de performances.
• Meilleures pratiques
  • Restez avec l'encodage UTF-8 pour la compatibilité entre les plateformes et les outils.
  • Testez avec des cas spéciaux tels que les nuls, les virgules, les guillemets et les valeurs multilignes pour éviter les erreurs inattendues.
  • Choisissez la bonne méthode – StringBuilder fonctionne bien pour les petites tables, StreamWriter est meilleur pour les grands ensembles de données, et Spire.XLS est idéal pour les solutions prêtes pour la production.
  • Documentez clairement la structure de votre CSV afin que les autres sachent comment interpréter les données.

Conclusion

Maîtriser la conversion C# DataTable en CSV est une compétence essentielle pour les développeurs travaillant avec des données tabulaires. Ce guide a couvert trois approches pratiques : l'utilisation de StringBuilder pour les petits ensembles de données, l'emploi de StreamWriter pour une gestion efficace et économe en mémoire des grandes tables, et l'exploitation de la bibliothèque Spire.XLS pour une solution fiable et prête pour la production qui gère automatiquement les scénarios complexes.

En suivant ces exemples étape par étape, vous pouvez effectuer la conversion C# DataTable en CSV en toute confiance, en vous assurant que vos données sont précises, partageables et prêtes pour l'intégration ou une analyse plus approfondie.

FAQ

Q1 : Comment puis-je convertir efficacement un DataTable en CSV en C# ?

R1 : Vous pouvez utiliser trois méthodes : la conversion manuelle avec StringBuilder pour les petits ensembles de données, StreamWriter pour les grands ensembles de données, ou la bibliothèque Spire.XLS pour une solution prête pour la production. Chaque méthode assure une gestion correcte des virgules, des guillemets et des sauts de ligne.

Q2 : Quel est le meilleur moyen d'exporter de grands DataTables C# en CSV ?

R2 : Pour les grands ensembles de données, StreamWriter est recommandé car il écrit les lignes une par une, réduisant ainsi l'utilisation de la mémoire. Spire.XLS est une autre option fiable pour les environnements de production.

Q3 : Comment gérer les caractères spéciaux et les valeurs nulles lors de l'exportation de DataTable en CSV en C# ?

R3 : Échappez toujours les virgules, les guillemets et les sauts de ligne. Remplacez les valeurs nulles ou DBNull par des chaînes vides ou des espaces réservés. L'utilisation de Spire.XLS gère automatiquement la plupart de ces cas.

Q4 : Puis-je personnaliser les délimiteurs et l'encodage lors de l'exportation d'un DataTable en CSV ?

R4 : Oui, vous pouvez spécifier des délimiteurs comme ,, ; ou \t et choisir un encodage tel que UTF-8, UTF-16 ou ANSI en fonction des exigences du système.

Q5 : Pourquoi devrais-je utiliser Spire.XLS au lieu des méthodes manuelles ou StreamWriter ?

R5 : Spire.XLS simplifie l'exportation CSV en gérant automatiquement l'échappement, les délimiteurs et l'encodage, réduit la complexité du code et est idéal pour les ensembles de données de taille moyenne à grande ou les applications de niveau production.

Q6 : Comment puis-je m'assurer que mon CSV exporté est compatible avec Excel et d'autres applications ?

R6 : Utilisez l'encodage UTF-8, échappez les caractères spéciaux et formatez les en-têtes de manière cohérente. Tester la sortie dans Excel ou d'autres applications cibles aide à éviter les problèmes de compatibilité.

Voir également

• C#/VB.NET : Convertir CSV en PDF
• C#/VB.NET : Convertir Excel en CSV
• Comment convertir Excel (XLS ou XLSX) en PDF en C# .NET
• C#/VB.NET : Convertir Excel en images