Lettura di file CSV utilizzando C #

Sto scrivendo una semplice applicazione di importazione e ho bisogno di leggere un file CSV, mostrare il risultato in DataGride mostrare righe danneggiate del file CSV in un'altra griglia. Ad esempio, mostra le linee che sono più brevi di 5 valori in un'altra griglia. Sto cercando di farlo in questo modo:

StreamReader sr = new StreamReader(FilePath);
importingData = new Account();
string line;
string[] row = new string [5];
while ((line = sr.ReadLine()) != null)
{
    row = line.Split(',');

    importingData.Add(new Transaction
    {
        Date = DateTime.Parse(row[0]),
        Reference = row[1],
        Description = row[2],
        Amount = decimal.Parse(row[3]),
        Category = (Category)Enum.Parse(typeof(Category), row[4])
    });
}

ma in questo caso è molto difficile operare su array. C'è un modo migliore per dividere i valori?

Non reinventare la ruota. Approfitta di ciò che è già in .NET BCL.

• aggiungi un riferimento a Microsoft.VisualBasic(sì, dice VisualBasic ma funziona anche in C # - ricorda che alla fine è tutto solo IL)
• usa la Microsoft.VisualBasic.FileIO.TextFieldParserclasse per analizzare il file CSV

Ecco il codice di esempio:

using (TextFieldParser parser = new TextFieldParser(@"c:\temp\test.csv"))
{
    parser.TextFieldType = FieldType.Delimited;
    parser.SetDelimiters(",");
    while (!parser.EndOfData) 
    {
        //Processing row
        string[] fields = parser.ReadFields();
        foreach (string field in fields) 
        {
            //TODO: Process field
        }
    }
}

Funziona benissimo per me nei miei progetti C #.

Ecco alcuni altri link / informazioni:

• MSDN: lettura da file di testo delimitati da virgole in Visual Basic
• MSDN: classe TextFieldParser

La mia esperienza è che ci sono molti diversi formati CSV. Specialmente come gestiscono l'escaping di virgolette e delimitatori all'interno di un campo.

Queste sono le varianti in cui mi sono imbattuto:

• le virgolette sono quotate e raddoppiate (excel) cioè 15 "-> field1," 15 "" ", field3
• le virgolette non vengono modificate a meno che il campo non sia quotato per qualche altro motivo. cioè 15 "-> field1,15", fields3
• le virgolette sono salvate con \. cioè 15 "-> field1," 15 \ "", field3
• le virgolette non vengono affatto modificate (non è sempre possibile analizzare correttamente)
• il delimitatore è citato (excel). cioè a, b -> campo1, "a, b", campo3
• il delimitatore viene eliminato con \. cioè a, b -> campo1, a \, b, campo3

Ho provato molti dei parser CSV esistenti ma non ce n'è uno in grado di gestire le varianti in cui mi sono imbattuto. È anche difficile scoprire dalla documentazione quali varianti di escape supportano i parser.

Nei miei progetti ora uso VB TextFieldParser o uno splitter personalizzato.

Consiglio CsvHelper di Nuget .

(L'aggiunta di un riferimento a Microsoft.VisualBasic non sembra giusto, non è solo brutta, probabilmente non è nemmeno multipiattaforma.)

A volte l'uso delle librerie è interessante quando non si desidera reinventare la ruota, ma in questo caso si può fare lo stesso lavoro con meno righe di codice e più facili da leggere rispetto all'utilizzo delle librerie. Ecco un approccio diverso che trovo molto facile da usare.

1. In questo esempio, utilizzo StreamReader per leggere il file
2. Regex per rilevare il delimitatore da ciascuna linea (e).
3. Un array per raccogliere le colonne dall'indice 0 al n

using (StreamReader reader = new StreamReader(fileName))
    {
        string line; 

        while ((line = reader.ReadLine()) != null)
        {
            //Define pattern
            Regex CSVParser = new Regex(",(?=(?:[^\"]*\"[^\"]*\")*(?![^\"]*\"))");

            //Separating columns to array
            string[] X = CSVParser.Split(line);

            /* Do something with X */
        }
    }

CSV possono complicarsi reale veloce.

Usa qualcosa di robusto e ben testato:
FileHelpers: www.filehelpers.net

FileHelpers è una libreria .NET gratuita e facile da usare per importare / esportare dati da record a lunghezza fissa o delimitati in file, stringhe o flussi.

Lo uso qui:

http://www.codeproject.com/KB/database/GenericParser.aspx

L'ultima volta che stavo cercando qualcosa del genere l'ho trovato come risposta a questa domanda .

Un altro di questo elenco, Cinchoo ETL - una libreria open source per leggere e scrivere file CSV

Per un esempio di file CSV di seguito

Id, Name
1, Tom
2, Mark

Puoi caricarli rapidamente usando la libreria come di seguito

using (var reader = new ChoCSVReader("test.csv").WithFirstLineHeader())
{
   foreach (dynamic item in reader)
   {
      Console.WriteLine(item.Id);
      Console.WriteLine(item.Name);
   }
}

Se si dispone della classe POCO corrispondente al file CSV

public class Employee
{
   public int Id { get; set; }
   public string Name { get; set; }
}

Puoi usarlo per caricare il file CSV come di seguito

using (var reader = new ChoCSVReader<Employee>("test.csv").WithFirstLineHeader())
{
   foreach (var item in reader)
   {
      Console.WriteLine(item.Id);
      Console.WriteLine(item.Name);
   }
}

Consulta gli articoli su CodeProject su come utilizzarlo.

Disclaimer: sono l'autore di questa biblioteca

private static DataTable ConvertCSVtoDataTable(string strFilePath)
        {
            DataTable dt = new DataTable();
            using (StreamReader sr = new StreamReader(strFilePath))
            {
                string[] headers = sr.ReadLine().Split(',');
                foreach (string header in headers)
                {
                    dt.Columns.Add(header);
                }
                while (!sr.EndOfStream)
                {
                    string[] rows = sr.ReadLine().Split(',');
                    DataRow dr = dt.NewRow();
                    for (int i = 0; i < headers.Length; i++)
                    {
                        dr[i] = rows[i];
                    }
                    dt.Rows.Add(dr);
                }

            }

            return dt;
        }

        private static void WriteToDb(DataTable dt)
        {
            string connectionString =
                "Data Source=localhost;" +
                "Initial Catalog=Northwind;" +
                "Integrated Security=SSPI;";

            using (SqlConnection con = new SqlConnection(connectionString))
                {
                    using (SqlCommand cmd = new SqlCommand("spInsertTest", con))
                    {
                        cmd.CommandType = CommandType.StoredProcedure;

                        cmd.Parameters.Add("@policyID", SqlDbType.Int).Value = 12;
                        cmd.Parameters.Add("@statecode", SqlDbType.VarChar).Value = "blagh2";
                        cmd.Parameters.Add("@county", SqlDbType.VarChar).Value = "blagh3";

                        con.Open();
                        cmd.ExecuteNonQuery();
                    }
                }

         }

Prima di tutto devi capire cos'è CSV e come scriverlo.

1. Ogni stringa successiva ( /r/n) è la riga successiva "tabella".
2. Le celle "Tabella" sono separate da un simbolo delimitatore. I simboli più usati sono \to,
3. Ogni cella può eventualmente contenere questo simbolo delimitatore (la cella deve iniziare con il simbolo delle virgolette e in questo caso termina con questo simbolo)
4. Ogni cella può contenere /r/nsimboli (la cella deve iniziare con il simbolo delle virgolette e in questo caso termina con questo simbolo)

Il modo più semplice per utilizzare C # / Visual Basic con i file CSV è utilizzare la Microsoft.VisualBasiclibreria standard . Devi solo aggiungere il riferimento necessario e la seguente stringa alla tua classe:

using Microsoft.VisualBasic.FileIO;

Sì, puoi usarlo in C #, non ti preoccupare. Questa libreria può leggere file relativamente grandi e supporta tutte le regole necessarie, così sarai in grado di lavorare con tutti i file CSV.

Qualche tempo fa avevo scritto lezioni semplici per CSV in lettura / scrittura basate su questa libreria. Usando questa semplice classe sarai in grado di lavorare con CSV come con un array di 2 dimensioni. Puoi trovare la mia classe al seguente link: https://github.com/ukushu/DataExporter

Semplice esempio di utilizzo:

Csv csv = new Csv("\t");//delimiter symbol

csv.FileOpen("c:\\file1.csv");

var row1Cell6Value = csv.Rows[0][5];

csv.AddRow("asdf","asdffffff","5")

csv.FileSave("c:\\file2.csv");

Per completare le risposte precedenti, potrebbe essere necessario un insieme di oggetti dal suo file CSV, analizzato dal metodo TextFieldParsero string.Split, e quindi ogni riga convertita in un oggetto tramite Reflection. Ovviamente devi prima definire una classe che corrisponda alle linee del file CSV.

Ho usato il semplice serializzatore CSV di Michael Kropat trovato qui: classe generica in CSV (tutte le proprietà) e riutilizzato i suoi metodi per ottenere i campi e le proprietà della classe desiderata.

Deserializzo il mio file CSV con il seguente metodo:

public static IEnumerable<T> ReadCsvFileTextFieldParser<T>(string fileFullPath, string delimiter = ";") where T : new()
{
    if (!File.Exists(fileFullPath))
    {
        return null;
    }

    var list = new List<T>();
    var csvFields = GetAllFieldOfClass<T>();
    var fieldDict = new Dictionary<int, MemberInfo>();

    using (TextFieldParser parser = new TextFieldParser(fileFullPath))
    {
        parser.SetDelimiters(delimiter);

        bool headerParsed = false;

        while (!parser.EndOfData)
        {
            //Processing row
            string[] rowFields = parser.ReadFields();
            if (!headerParsed)
            {
                for (int i = 0; i < rowFields.Length; i++)
                {
                    // First row shall be the header!
                    var csvField = csvFields.Where(f => f.Name == rowFields[i]).FirstOrDefault();
                    if (csvField != null)
                    {
                        fieldDict.Add(i, csvField);
                    }
                }
                headerParsed = true;
            }
            else
            {
                T newObj = new T();
                for (int i = 0; i < rowFields.Length; i++)
                {
                    var csvFied = fieldDict[i];
                    var record = rowFields[i];

                    if (csvFied is FieldInfo)
                    {
                        ((FieldInfo)csvFied).SetValue(newObj, record);
                    }
                    else if (csvFied is PropertyInfo)
                    {
                        var pi = (PropertyInfo)csvFied;
                        pi.SetValue(newObj, Convert.ChangeType(record, pi.PropertyType), null);
                    }
                    else
                    {
                        throw new Exception("Unhandled case.");
                    }
                }
                if (newObj != null)
                {
                    list.Add(newObj);
                }
            }
        }
    }
    return list;
}

public static IEnumerable<MemberInfo> GetAllFieldOfClass<T>()
{
    return
        from mi in typeof(T).GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)
        where new[] { MemberTypes.Field, MemberTypes.Property }.Contains(mi.MemberType)
        let orderAttr = (ColumnOrderAttribute)Attribute.GetCustomAttribute(mi, typeof(ColumnOrderAttribute))
        orderby orderAttr == null ? int.MaxValue : orderAttr.Order, mi.Name
        select mi;            
}

Consiglio vivamente di usare CsvHelper.

Ecco un breve esempio:

public class csvExampleClass
{
    public string Id { get; set; }
    public string Firstname { get; set; }
    public string Lastname { get; set; }
}

var items = DeserializeCsvFile<List<csvExampleClass>>( csvText );

public static List<T> DeserializeCsvFile<T>(string text)
{
    CsvReader csv = new CsvReader( new StringReader( text ) );
    csv.Configuration.Delimiter = ",";
    csv.Configuration.HeaderValidated = null;
    csv.Configuration.MissingFieldFound = null;
    return (List<T>)csv.GetRecords<T>();
}

La documentazione completa è disponibile all'indirizzo: https://joshclose.github.io/CsvHelper