Importer un fichier CSV vers une structure de données fortement typée en .Net

Question

Quelle est la meilleure façon d'importer un fichier CSV dans une structure de données fortement typée ?

Answer 1

Microsoft TextFieldParser est stable et suit RFC 4180 pour les fichiers CSV. Ne vous laissez pas décourager par le Microsoft.VisualBasic Il s'agit d'un composant standard dans le .NET Framework. Il suffit d'ajouter une référence à l'espace de noms global de l'entreprise. Microsoft.VisualBasic montage.

Si vous compilez pour Windows (par opposition à Mono) et ne prévoyez pas d'avoir à analyser des fichiers CSV "cassés" (non conformes au RFC), alors ce serait le choix évident, car il est gratuit, sans restriction, stable et activement supporté, ce qui n'est pas le cas de FileHelpers.

Voir aussi : Comment faire : Lire des fichiers texte délimités par des virgules en Visual Basic pour un exemple de code VB.

Answer 2

Vérifiez FileHelpers .

Answer 3

Utilisez une connexion OleDB.

String sConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\InputDirectory\\;Extended Properties='text;HDR=Yes;FMT=Delimited'";
OleDbConnection objConn = new OleDbConnection(sConnectionString);
objConn.Open();
DataTable dt = new DataTable();
OleDbCommand objCmdSelect = new OleDbCommand("SELECT * FROM file.csv", objConn);
OleDbDataAdapter objAdapter1 = new OleDbDataAdapter();
objAdapter1.SelectCommand = objCmdSelect;
objAdapter1.Fill(dt);
objConn.Close();

Answer 4

Si vous vous attendez à des scénarios assez complexes pour l'analyse CSV, ne pense même pas à mettre en place notre propre analyseur syntaxique. . Il existe un grand nombre d'excellents outils, tels que FileHelpers ou même ceux de CodeProject .

Le fait est qu'il s'agit d'un problème assez courant et vous pouvez parier que beaucoup de développeurs de logiciels ont déjà réfléchi à ce problème et l'ont résolu.

Answer 5

Brian propose une solution intéressante pour la convertir en une collection fortement typée.

La plupart des méthodes d'analyse CSV proposées ne tiennent pas compte de l'échappement des champs ou de certaines autres subtilités des fichiers CSV (comme le découpage des champs). Voici le code que j'utilise personnellement. Il est un peu brut de décoffrage et n'a pratiquement aucun rapport d'erreur.

public static IList<IList<string>> Parse(string content)
{
    IList<IList<string>> records = new List<IList<string>>();

    StringReader stringReader = new StringReader(content);

    bool inQoutedString = false;
    IList<string> record = new List<string>();
    StringBuilder fieldBuilder = new StringBuilder();
    while (stringReader.Peek() != -1)
    {
        char readChar = (char)stringReader.Read();

        if (readChar == '\n' || (readChar == '\r' && stringReader.Peek() == '\n'))
        {
            // If it's a \r\n combo consume the \n part and throw it away.
            if (readChar == '\r')
            {
                stringReader.Read();
            }

            if (inQoutedString)
            {
                if (readChar == '\r')
                {
                    fieldBuilder.Append('\r');
                }
                fieldBuilder.Append('\n');
            }
            else
            {
                record.Add(fieldBuilder.ToString().TrimEnd());
                fieldBuilder = new StringBuilder();

                records.Add(record);
                record = new List<string>();

                inQoutedString = false;
            }
        }
        else if (fieldBuilder.Length == 0 && !inQoutedString)
        {
            if (char.IsWhiteSpace(readChar))
            {
                // Ignore leading whitespace
            }
            else if (readChar == '"')
            {
                inQoutedString = true;
            }
            else if (readChar == ',')
            {
                record.Add(fieldBuilder.ToString().TrimEnd());
                fieldBuilder = new StringBuilder();
            }
            else
            {
                fieldBuilder.Append(readChar);
            }
        }
        else if (readChar == ',')
        {
            if (inQoutedString)
            {
                fieldBuilder.Append(',');
            }
            else
            {
                record.Add(fieldBuilder.ToString().TrimEnd());
                fieldBuilder = new StringBuilder();
            }
        }
        else if (readChar == '"')
        {
            if (inQoutedString)
            {
                if (stringReader.Peek() == '"')
                {
                    stringReader.Read();
                    fieldBuilder.Append('"');
                }
                else
                {
                    inQoutedString = false;
                }
            }
            else
            {
                fieldBuilder.Append(readChar);
            }
        }
        else
        {
            fieldBuilder.Append(readChar);
        }
    }
    record.Add(fieldBuilder.ToString().TrimEnd());
    records.Add(record);

    return records;
}

Notez que cela ne gère pas le cas limite des champs qui ne sont pas délimités par des guillemets doubles, mais qui contiennent simplement une chaîne entre guillemets. Voir ce poste pour une meilleure explication ainsi que des liens vers de bonnes bibliothèques.