Ausführliche Erklärung zum Lesen und Schreiben von CSV-Dateien in C#

Inhaltsverzeichnis

• CSV-Dateistandard
  • Dateibeispiel
  • RFC 4180
  • Vereinfachungsstandards
• CSV-Dateien lesen und schreiben
  • Verwenden von CsvHelper
  • Benutzerdefinierte Methode verwenden
• Zusammenfassen

In Projekten stoßen wir häufig auf die Notwendigkeit, CSV-Dateien zu lesen und zu schreiben. Die Hauptschwierigkeit ist das Parsen von CSV-Dateien. In diesem Artikel werden drei Methoden zum Parsen von CSV-Dateien vorgestellt : CsvHelper , TextFieldParser und reguläre Ausdrücke . Übrigens wird auch vorgestellt, wie man CSV-Dateien schreibt.

CSV-Dateistandard

Bevor wir die Lese- und Schreibmethoden von CSV-Dateien vorstellen, müssen wir das Format von CSV-Dateien verstehen.

Dateibeispiel

Eine einfache CSV-Datei:

?

Test1,Test2,Test3,Test4,Test5,Test6
str1,str2,str3,str4,str5,str6
str1,str2,str3,str4,str5,str6

Eine nicht ganz so einfache CSV-Datei:

?

"Test1
"",""","Test2
"",""","Test3
"",""","Test4
"",""","Test5
"",""","Test6
"","""
" 中文,D23 ","3DFD4234""""""1232""1S2","ASD1"",""23,,,,213
23F32","
",,asd
" 中文,D23 ","3DFD4234""""""1232""1S2","ASD1"",""23,,,,213
23F32","
",,asd

Sie haben richtig gelesen, die beiden oben genannten sind beide CSV-Dateien und beide enthalten nur drei Zeilen mit CSV-Daten. Das zweite Betrachten der zweiten Datei ist eine mentale Verschmutzung, aber es ist unvermeidlich, dass solche Dateien im Projekt auftauchen.

RFC 4180

Es gibt keinen offiziellen Standard für CSV-Dateien, aber allgemeine Projekte entsprechen dem RFC 4180-Standard. Dies ist ein inoffizieller Standard und der Inhalt ist wie folgt:

Jeder Datensatz befindet sich in einer separaten Zeile, die durch einen Zeilenumbruch (CRLF) getrennt ist.

Der letzte Datensatz in der Datei kann einen Zeilenumbruch am Ende haben oder auch nicht.

Möglicherweise erscheint als erste Zeile der Datei eine optionale Kopfzeile mit demselben Format wie normale Datensatzzeilen. Dieser Header enthält Namen, die den Feldern in der Datei entsprechen, und sollte die gleiche Anzahl von Feldern enthalten wie die Datensätze im Rest der Datei (das Vorhandensein oder Fehlen der Headerzeile sollte über den optionalen Parameter „header“ angegeben werden). Mime Typ).

Innerhalb der Kopfzeile und jedes Datensatzes können ein oder mehrere durch Kommas getrennte Felder vorhanden sein. Jede Zeile in der gesamten Datei sollte die gleiche Anzahl an Feldern enthalten. Leerzeichen gelten als Teil eines Feldes und sollten nicht ignoriert werden. Auf das letzte Feld im Datensatz darf kein Komma folgen.

Jedes Feld kann in doppelte Anführungszeichen eingeschlossen sein oder auch nicht (einige Programme wie Microsoft Excel verwenden jedoch überhaupt keine doppelten Anführungszeichen). Wenn Felder nicht in doppelte Anführungszeichen eingeschlossen sind, werden in den Feldern möglicherweise keine doppelten Anführungszeichen angezeigt.

Felder, die Zeilenumbrüche (CRLF), doppelte Anführungszeichen und Kommas enthalten, sollten in doppelte Anführungszeichen gesetzt werden.

Wenn doppelte Anführungszeichen zum Einschließen von Feldern verwendet werden, muss ein doppeltes Anführungszeichen, das innerhalb eines Felds erscheint, durch ein vorangehendes weiteres doppeltes Anführungszeichen maskiert werden.

übersetzen:

• Jeder Datensatz befindet sich in einer separaten Zeile, getrennt durch ein Zeilenumbruchzeichen (CRLF).
• Der letzte Datensatz in der Datei kann ein abschließendes Zeilenumbruchzeichen haben oder auch nicht.
• Möglicherweise gibt es eine optionale Kopfzeile, die als erste Zeile der Datei im gleichen Format wie eine normale Datensatzzeile angezeigt wird. Dieser Header enthält Namen, die den Feldern in der Datei entsprechen, und sollte die gleiche Anzahl von Feldern enthalten wie die Datensätze im Rest der Datei (das Vorhandensein oder Fehlen einer Headerzeile sollte durch den optionalen Parameter „header“ angezeigt werden). dieses MIME-Typs).
• Im Header und in jedem Datensatz können ein oder mehrere durch Kommas getrennte Felder vorhanden sein. In der gesamten Datei sollte jede Zeile die gleiche Anzahl an Feldern enthalten. Leerzeichen gelten als Teil des Feldes und sollten nicht ignoriert werden. Nach dem letzten Feld im Datensatz darf kein Komma stehen.
• Jedes Feld kann in doppelte Anführungszeichen eingeschlossen werden oder nicht (einige Programme wie Microsoft Excel verwenden jedoch überhaupt keine doppelten Anführungszeichen). Wenn das Feld nicht in doppelte Anführungszeichen gesetzt ist, werden die doppelten Anführungszeichen möglicherweise nicht im Feld angezeigt.
• Felder, die Zeilenumbrüche (CRLF), doppelte Anführungszeichen und Kommas enthalten, sollten in doppelte Anführungszeichen gesetzt werden.
• Wenn Sie ein Feld in doppelte Anführungszeichen einschließen, muss dem im Feld angezeigten doppelten Anführungszeichen ein weiteres doppeltes Anführungszeichen vorangestellt werden.

Vereinfachungsstandards

Der obige Standard ist möglicherweise etwas schwierig auszusprechen, daher werden wir ihn etwas vereinfachen. Es ist zu beachten, dass Vereinfachung nicht einfach darin besteht, Regeln zu streichen, sondern ähnliche Regeln zum besseren Verständnis zusammenzuführen.
Der folgende Code verwendet auch die folgenden Vereinfachungskriterien:

• Jeder Datensatz befindet sich in einer separaten Zeile, getrennt durch ein Zeilenumbruchzeichen (CRLF).
• Hinweis: Die Zeile hier ist keine Zeile im herkömmlichen Textsinn, sondern bezieht sich auf einen Datensatz, der dem CSV-Dateiformat entspricht (im Folgenden als CSV-Zeile bezeichnet ), der mehrere Zeilen im Text belegen kann.
• Der letzte Datensatz in der Datei muss ein abschließendes Zeilenumbruchzeichen haben und die erste Zeile der Datei muss eine Kopfzeile sein (die Kopfzeile enthält die Namen, die den Feldern entsprechen, und die Anzahl der Kopfzeilen entspricht der Anzahl der Felder im Protokoll).
• Hinweis: Die optionalen Optionen im ursprünglichen Standard sind einheitlich als obligatorisch angegeben, um eine spätere Analyse zu erleichtern, und es gibt keine Kopfzeile, um anderen die Daten anzuzeigen.
• Im Header und in jedem Datensatz können ein oder mehrere durch Kommas getrennte Felder vorhanden sein. In der gesamten Datei sollte jede Zeile die gleiche Anzahl an Feldern enthalten . Leerzeichen gelten als Teil des Feldes und sollten nicht ignoriert werden . Nach dem letzten Feld im Datensatz darf kein Komma stehen .
• Hinweis: Dieser Standard wurde nicht vereinfacht. Obwohl es andere Standards gibt, die Leerzeichen, Tabulatoren usw. zur Trennung verwenden, werden Dateien, die nicht durch Kommas getrennt sind, immer noch als durch Kommas getrennte Wertedateien bezeichnet?
• Jedes Feld ist in doppelte Anführungszeichen eingeschlossen, und einem doppelten Anführungszeichen, das in einem Feld erscheint, muss ein weiteres doppeltes Anführungszeichen vorangestellt sein
• Hinweis: Im ursprünglichen Standard gibt es Situationen, in denen doppelte Anführungszeichen verwendet werden müssen und optionale doppelte Anführungszeichen verwendet werden. Daher wird es definitiv nicht schief gehen, wenn alle doppelten Anführungszeichen verwendet werden. *

CSV-Dateien lesen und schreiben

Bevor wir CSV-Dateien offiziell lesen und schreiben können, müssen wir eine Testklasse zum Testen definieren. Code wie folgt anzeigen:

?

class Test
{
    public string Test1{ get;set;}
    public string Test2 { get; set; }
    public string Test3 { get; set; }
    public string Test4 { get; set; }
    public string Test5 { get; set; }
    public string Test6 { get; set; }

    //Parse方法会在自定义读写CSV文件时用到
    public static Test Parse (string[]fields )
    {
        try
        {
            Test ret = new Test();
            ret.Test1 = fields[0];
            ret.Test2 = fields[1];
            ret.Test3 = fields[2];
            ret.Test4 = fields[3];
            ret.Test5 = fields[4];
            ret.Test6 = fields[5];
            return ret;
        }
        catch (Exception)
        {
            //做一些异常处理，写日志之类的
            return null;
        }
    }
}

Generieren Sie einige Testdaten. Der Code lautet wie folgt:

?

static void Main(string[] args)
{
    //文件保存路径
    string path = "tset.csv";
    //清理之前的测试文件
    File.Delete("tset.csv");

    Test test = new Test();
    test.Test1 = " 中文,D23 ";
    test.Test2 = "3DFD4234\"\"\"1232\"1S2";
    test.Test3 = "ASD1\",\"23,,,,213\r23F32";
    test.Test4 = "\r";
    test.Test5 = string.Empty;
    test.Test6 = "asd";

    //测试数据
    var records = new List<Test> { test, test };

    //写CSV文件
    /*
    *直接把后面的写CSV文件代码复制到此处
    */

    //读CSV文件
     /*
    *直接把后面的读CSV文件代码复制到此处
    */

    Console.ReadLine();
}

Verwenden von CsvHelper

CsvHelper ist eine Bibliothek zum Lesen und Schreiben von CSV-Dateien und unterstützt das Lesen und Schreiben benutzerdefinierter Klassenobjekte.

github上标星最高的CSV文件读写C#库，使用MS-PL、Apache 2.0开源协议。

使用NuGet下载CsvHelper，读写CSV文件的代码如下：

?

//写CSV文件
using (var writer = new StreamWriter(path))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
    csv.WriteRecords(records);
}

using (var writer = new StreamWriter(path,true))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
    //追加
    foreach (var record in records)
    {
        csv.WriteRecord(record);
    }
}

//读CSV文件
using (var reader = new StreamReader(path))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
    records = csv.GetRecords<Test>().ToList();
    //逐行读取
    //records.Add(csv.GetRecord<Test>());
}

如果你只想要拿来就能用的库，那文章基本上到这里就结束了。

使用自定义方法

为了与CsvHelper区分，新建一个CsvFile类存放自定义读写CSV文件的代码，最后会提供类的完整源码。CsvFile类定义如下：

?

/// <summary>
/// CSV文件读写工具类
/// </summary>
public class CsvFile
{
    #region 写CSV文件
    //具体代码...
    #endregion

    #region 读CSV文件（使用TextFieldParser）
    //具体代码...
    #endregion

    #region 读CSV文件（使用正则表达式）
    //具体代码...
    #endregion

}

基于简化标准的写CSV文件

根据简化标准（具体标准内容见前文），写CSV文件代码如下：

?

#region 写CSV文件
//字段数组转为CSV记录行
private static string FieldsToLine(IEnumerable<string> fields)
{
    if (fields == null) return string.Empty;
    fields = fields.Select(field =>
    {
        if (field == null) field = string.Empty;
        //简化标准，所有字段都加双引号
        field = string.Format("\"{0}\"", field.Replace("\"", "\"\""));

        //不简化标准
        //field = field.Replace("\"", "\"\"");
        //if (field.IndexOfAny(new char[] { ',', '"', ' ', '\r' }) != -1)
        //{
        //    field = string.Format("\"{0}\"", field);
        //}
        return field;
    });
    string line = string.Format("{0}{1}", string.Join(",", fields), Environment.NewLine);
    return line;
}

//默认的字段转换方法
private static IEnumerable<string> GetObjFields<T>(T obj, bool isTitle) where T : class
{
    IEnumerable<string> fields;
    if (isTitle)
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.Name);
    }
    else
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.GetValue(obj)?.ToString());
    }
    return fields;
}

/// <summary>
/// 写CSV文件，默认第一行为标题
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list">数据列表</param>
/// <param name="path">文件路径</param>
/// <param name="append">追加记录</param>
/// <param name="func">字段转换方法</param>
/// <param name="defaultEncoding"></param>
public static void Write<T>(List<T> list, string path,bool append=true, Func<T, bool, IEnumerable<string>> func = null, Encoding defaultEncoding = null) where T : class
{
    if (list == null || list.Count == 0) return;
    if (defaultEncoding == null)
    {
        defaultEncoding = Encoding.UTF8;
    }
    if (func == null)
    {
        func = GetObjFields;
    }
    if (!File.Exists(path)|| !append)
    {
        var fields = func(list[0], true);
        string title = FieldsToLine(fields);
        File.WriteAllText(path, title, defaultEncoding);
    }
    using (StreamWriter sw = new StreamWriter(path, true, defaultEncoding))
    {
        list.ForEach(obj =>
        {
            var fields = func(obj, false);
            string line = FieldsToLine(fields);
            sw.Write(line);
        });
    }
}
#endregion

使用时，代码如下：

?

//写CSV文件
//使用自定义的字段转换方法，也是文章开头复杂CSV文件使用字段转换方法
CsvFile.Write(records, path, true, new Func<Test, bool, IEnumerable<string>>((obj, isTitle) =>
{
    IEnumerable<string> fields;
    if (isTitle)
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.Name + Environment.NewLine + "\",\"");
    }
    else
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.GetValue(obj)?.ToString());
    }
    return fields;
}));

//使用默认的字段转换方法
//CsvFile.Write(records, path);

你也可以使用默认的字段转换方法，代码如下：

?

CsvFile.Save(records, path);

使用TextFieldParser解析CSV文件

TextFieldParser是VB中解析CSV文件的类，C#虽然没有类似功能的类，不过可以调用VB的TextFieldParser来实现功能。

TextFieldParser解析CSV文件的代码如下：

?

#region 读CSV文件（使用TextFieldParser）
/// <summary>
/// 读CSV文件，默认第一行为标题
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">文件路径</param>
/// <param name="func">字段解析规则</param>
/// <param name="defaultEncoding">文件编码</param>
/// <returns></returns>
public static List<T> Read<T>(string path, Func<string[], T> func, Encoding defaultEncoding = null) where T : class
{
    if (defaultEncoding == null)
    {
        defaultEncoding = Encoding.UTF8;
    }
    List<T> list = new List<T>();
    using (TextFieldParser parser = new TextFieldParser(path, defaultEncoding))
    {
        parser.TextFieldType = FieldType.Delimited;
        //设定逗号分隔符
        parser.SetDelimiters(",");
        //设定不忽略字段前后的空格
        parser.TrimWhiteSpace = false;
        bool isLine = false;
        while (!parser.EndOfData)
        {
            string[] fields = parser.ReadFields();
            if (isLine)
            {
                var obj = func(fields);
                if (obj != null) list.Add(obj);
            }
            else
            {
                //忽略标题行业
                isLine = true;
            }
        }
    }
    return list;
}
#endregion

使用时，代码如下：

?

//读CSV文件
records = CsvFile.Read(path, Test.Parse);

使用正则表达式解析CSV文件

如果你有一个问题，想用正则表达式来解决，那么你就有两个问题了。

正则表达式有一定的学习门槛，而且学习后不经常使用就会忘记。正则表达式解决的大多数是一些不易变更需求的问题，这就导致一个稳定可用的正则表达式可以传好几代。

本节的正则表达式来自 《精通正则表达式（第3版）》 第6章 打造高效正则表达式——简单的消除循环的例子，有兴趣的可以去了解一下，表达式说明如下：

Hinweis: Die endgültige Version des regulären Ausdrucks zum Parsen von CSV-Dateien in diesem Buch ist die Java-Version, die Possessivquantoren anstelle von fester Gruppierung verwendet. Es handelt sich auch um eine Version, die häufig auf Baidu zu finden ist. Es gibt jedoch ein Problem mit dem Possessivprioritätsquantifizierer in C#. Da ich aufgrund meiner eingeschränkten Fähigkeiten nicht in der Lage bin, es zu lösen, habe ich die oben gezeigte Version verwendet. Es gibt jedoch keinen Leistungsunterschied zwischen den beiden Versionen regulärer Ausdrücke.

Der Code der CSV-Datei zum Parsen regulärer Ausdrücke lautet wie folgt:

?

#region 读CSV文件（使用正则表达式）
/// <summary>
/// 读CSV文件，默认第一行为标题
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">文件路径</param>
/// <param name="func">字段解析规则</param>
/// <param name="defaultEncoding">文件编码</param>
/// <returns></returns>
public static List<T> Read_Regex<T>(string path, Func<string[], T> func, Encoding defaultEncoding = null) where T : class
{
    List<T> list = new List<T>();
    StringBuilder sbr = new StringBuilder(100);
    Regex lineReg = new Regex("\"");
    Regex fieldReg = new Regex("\\G(?:^|,)(?:\"((?>[^\"]*)(?>\"\"[^\"]*)*)\"|([^\",]*))");
    Regex quotesReg = new Regex("\"\"");

    bool isLine = false;
    string line = string.Empty;
    using (StreamReader sr = new StreamReader(path))
    {
        while (null != (line = ReadLine(sr)))
        {
            sbr.Append(line);
            string str = sbr.ToString();
            //一个完整的CSV记录行，它的双引号一定是偶数
            if (lineReg.Matches(sbr.ToString()).Count % 2 == 0)
            {
                if (isLine)
                {
                    var fields = ParseCsvLine(sbr.ToString(), fieldReg, quotesReg).ToArray();
                    var obj = func(fields.ToArray());
                    if (obj != null) list.Add(obj);
                }
                else
                {
                    //忽略标题行业
                    isLine = true;
                }
                sbr.Clear();
            }
            else
            {
                sbr.Append(Environment.NewLine);
            }
        }
    }
    if (sbr.Length > 0)
    {
        //有解析失败的字符串，报错或忽略
    }
    return list;
}

//重写ReadLine方法，只有\r\n才是正确的一行
private static string ReadLine(StreamReader sr)
{
    StringBuilder sbr = new StringBuilder();
    char c;
    int cInt;
    while (-1 != (cInt =sr.Read()))
    {
        c = (char)cInt;
        if (c == '\n' && sbr.Length > 0 && sbr[sbr.Length - 1] == '\r')
        {
            sbr.Remove(sbr.Length - 1, 1);
            return sbr.ToString();
        }
        else
        {
            sbr.Append(c);
        }
    }
    return sbr.Length>0?sbr.ToString():null;
}

private static List<string> ParseCsvLine(string line, Regex fieldReg, Regex quotesReg)
{
    var fieldMath = fieldReg.Match(line);
    List<string> fields = new List<string>();
    while (fieldMath.Success)
    {
        string field;
        if (fieldMath.Groups[1].Success)
        {
            field = quotesReg.Replace(fieldMath.Groups[1].Value, "\"");
        }
        else
        {
            field = fieldMath.Groups[2].Value;
        }
        fields.Add(field);
        fieldMath = fieldMath.NextMatch();
    }
    return fields;
}
#endregion

Der verwendete Code lautet wie folgt:

?

//读CSV文件
records = CsvFile.Read_Regex(path, Test.Parse);

Bisher wurden keine Fehler beim Parsen regulärer Ausdrücke gefunden, die Verwendung wird jedoch weiterhin nicht empfohlen.

Vollständige CsvFile-Toolklasse

Der vollständige CsvFile-Klassencode lautet wie folgt:

?

using Microsoft.VisualBasic.FileIO;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;


namespace ConsoleApp4
{
    /// <summary>
    /// CSV文件读写工具类
    /// </summary>
    public class CsvFile
    {
        #region 写CSV文件
        //字段数组转为CSV记录行
        private static string FieldsToLine(IEnumerable<string> fields)
        {
            if (fields == null) return string.Empty;
            fields = fields.Select(field =>
            {
                if (field == null) field = string.Empty;
                //所有字段都加双引号
                field = string.Format("\"{0}\"", field.Replace("\"", "\"\""));

                //不简化
                //field = field.Replace("\"", "\"\"");
                //if (field.IndexOfAny(new char[] { ',', '"', ' ', '\r' }) != -1)
                //{
                //    field = string.Format("\"{0}\"", field);
                //}
                return field;
            });
            string line = string.Format("{0}{1}", string.Join(",", fields), Environment.NewLine);
            return line;
        }

        //默认的字段转换方法
        private static IEnumerable<string> GetObjFields<T>(T obj, bool isTitle) where T : class
        {
            IEnumerable<string> fields;
            if (isTitle)
            {
                fields = obj.GetType().GetProperties().Select(pro => pro.Name);
            }
            else
            {
                fields = obj.GetType().GetProperties().Select(pro => pro.GetValue(obj)?.ToString());
            }
            return fields;
        }

        /// <summary>
        /// 写CSV文件，默认第一行为标题
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">数据列表</param>
        /// <param name="path">文件路径</param>
        /// <param name="append">追加记录</param>
        /// <param name="func">字段转换方法</param>
        /// <param name="defaultEncoding"></param>
        public static void Write<T>(List<T> list, string path,bool append=true, Func<T, bool, IEnumerable<string>> func = null, Encoding defaultEncoding = null) where T : class
        {
            if (list == null || list.Count == 0) return;
            if (defaultEncoding == null)
            {
                defaultEncoding = Encoding.UTF8;
            }
            if (func == null)
            {
                func = GetObjFields;
            }
            if (!File.Exists(path)|| !append)
            {
                var fields = func(list[0], true);
                string title = FieldsToLine(fields);
                File.WriteAllText(path, title, defaultEncoding);
            }
            using (StreamWriter sw = new StreamWriter(path, true, defaultEncoding))
            {
                list.ForEach(obj =>
                {
                    var fields = func(obj, false);
                    string line = FieldsToLine(fields);
                    sw.Write(line);
                });
            }
        }
        #endregion

        #region 读CSV文件（使用TextFieldParser）
        /// <summary>
        /// 读CSV文件，默认第一行为标题
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path">文件路径</param>
        /// <param name="func">字段解析规则</param>
        /// <param name="defaultEncoding">文件编码</param>
        /// <returns></returns>
        public static List<T> Read<T>(string path, Func<string[], T> func, Encoding defaultEncoding = null) where T : class
        {
            if (defaultEncoding == null)
            {
                defaultEncoding = Encoding.UTF8;
            }
            List<T> list = new List<T>();
            using (TextFieldParser parser = new TextFieldParser(path, defaultEncoding))
            {
                parser.TextFieldType = FieldType.Delimited;
                //设定逗号分隔符
                parser.SetDelimiters(",");
                //设定不忽略字段前后的空格
                parser.TrimWhiteSpace = false;
                bool isLine = false;
                while (!parser.EndOfData)
                {
                    string[] fields = parser.ReadFields();
                    if (isLine)
                    {
                        var obj = func(fields);
                        if (obj != null) list.Add(obj);
                    }
                    else
                    {
                        //忽略标题行业
                        isLine = true;
                    }
                }
            }
            return list;
        }
        #endregion

        #region 读CSV文件（使用正则表达式）
        /// <summary>
        /// 读CSV文件，默认第一行为标题
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path">文件路径</param>
        /// <param name="func">字段解析规则</param>
        /// <param name="defaultEncoding">文件编码</param>
        /// <returns></returns>
        public static List<T> Read_Regex<T>(string path, Func<string[], T> func, Encoding defaultEncoding = null) where T : class
        {
            List<T> list = new List<T>();
            StringBuilder sbr = new StringBuilder(100);
            Regex lineReg = new Regex("\"");
            Regex fieldReg = new Regex("\\G(?:^|,)(?:\"((?>[^\"]*)(?>\"\"[^\"]*)*)\"|([^\",]*))");
            Regex quotesReg = new Regex("\"\"");

            bool isLine = false;
            string line = string.Empty;
            using (StreamReader sr = new StreamReader(path))
            {
                while (null != (line = ReadLine(sr)))
                {
                    sbr.Append(line);
                    string str = sbr.ToString();
                    //一个完整的CSV记录行，它的双引号一定是偶数
                    if (lineReg.Matches(sbr.ToString()).Count % 2 == 0)
                    {
                        if (isLine)
                        {
                            var fields = ParseCsvLine(sbr.ToString(), fieldReg, quotesReg).ToArray();
                            var obj = func(fields.ToArray());
                            if (obj != null) list.Add(obj);
                        }
                        else
                        {
                            //忽略标题行业
                            isLine = true;
                        }
                        sbr.Clear();
                    }
                    else
                    {
                        sbr.Append(Environment.NewLine);
                    }
                }
            }
            if (sbr.Length > 0)
            {
                //有解析失败的字符串，报错或忽略
            }
            return list;
        }

        //重写ReadLine方法，只有\r\n才是正确的一行
        private static string ReadLine(StreamReader sr)
        {
            StringBuilder sbr = new StringBuilder();
            char c;
            int cInt;
            while (-1 != (cInt =sr.Read()))
            {
                c = (char)cInt;
                if (c == '\n' && sbr.Length > 0 && sbr[sbr.Length - 1] == '\r')
                {
                    sbr.Remove(sbr.Length - 1, 1);
                    return sbr.ToString();
                }
                else
                {
                    sbr.Append(c);
                }
            }
            return sbr.Length>0?sbr.ToString():null;
        }

        private static List<string> ParseCsvLine(string line, Regex fieldReg, Regex quotesReg)
        {
            var fieldMath = fieldReg.Match(line);
            List<string> fields = new List<string>();
            while (fieldMath.Success)
            {
                string field;
                if (fieldMath.Groups[1].Success)
                {
                    field = quotesReg.Replace(fieldMath.Groups[1].Value, "\"");
                }
                else
                {
                    field = fieldMath.Groups[2].Value;
                }
                fields.Add(field);
                fieldMath = fieldMath.NextMatch();
            }
            return fields;
        }
        #endregion

    }
}

So verwenden Sie es:

?

//写CSV文件
CsvFile.Write(records, path, true, new Func<Test, bool, IEnumerable<string>>((obj, isTitle) =>
{
    IEnumerable<string> fields;
    if (isTitle)
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.Name + Environment.NewLine + "\",\"");
    }
    else
    {
        fields = obj.GetType().GetProperties().Select(pro => pro.GetValue(obj)?.ToString());
    }
    return fields;
}));

//读CSV文件
records = CsvFile.Read(path, Test.Parse);

//读CSV文件
records = CsvFile.Read_Regex(path, Test.Parse);